# Dmitry Ivanov: AI Implementation Engineer

> Portfolio of 28 AI systems and agents shipped to production or as working prototypes: document processing, classification, RAG, voice agents, outreach, local LLMs, developer tooling. Interactive map of the projects at https://neurocraft.space/.

Dmitry Ivanov builds and ships applied LLM systems end to end: from prompt and schema design, evals and retrieval to deployment and monitoring. Status labels: "Production" means real users or real data; "Working prototype" means it works end to end but is not a full rollout.

Index: https://neurocraft.space/llms.txt

## Projects in production

### SMS risk classifier

- Status: Production
- For: Product & growth
- Areas: Classification
- Key numbers: 8M+ messages · 98.9%
- Solution type: Classification
- Languages: C#, Python

Spam, phishing and compliance scoring for a US SMS provider.

- Designed the LLM layer: the prompt and a schema-guided (SGR) output format, tuned over 3 weeks.
- A cheap pre-check, regex plus dictionaries with look-alike letter (homoglyph) detection, handles the obvious cases before a model is called.
- Golden set from real and generated messages, labeled by hand: 98.9% accuracy on the evals.
- In production: 8M+ messages processed, up to 200 per second.

Pipeline: SMS message -> Pre-check: regex + dictionary + homoglyph detection -> LLM with schema-guided reasoning (SGR) -> Risk verdict -> Logged for metrics and review

Stack: C#, .NET, Python for prototyping, Schema-guided reasoning

### Tender Processing

- Status: Production
- For: Enterprise & operations
- Areas: Documents, Classification, Enterprise
- Key numbers: 300–500 emails a day · 92%
- Solution type: Classification, Extraction & OCR, Local LLMs
- Languages: Python, TypeScript / JS

Tender emails in, classified tenders and ERP-matched line items out.

- Intake for an industrial equipment distributor: 300 to 500 tender emails a day from 30+ sources.
- Custom parsers for 9 procurement platforms.
- Every tender is classified by type, properties and urgency.
- A local LLM extracts line items and matches them to an ERP catalog of 450K+ items. Classification accuracy: 92%.

Pipeline: Tender email -> Cleanup and normalization -> Unification -> Primary classification -> Parsing per platform -> Tender classification + ERP matching

Stack: Python, TypeScript, Flask, Redis + RQ, PostgreSQL, Qwen3 on vLLM, Playwright, Docker, React

### Living Status

- Status: Production
- For: Developers & AI builders
- Areas: Agents & infra, Knowledge & RAG
- Key numbers: every commit tied to a card
- Solution type: Agents & automation, RAG & search
- Languages: Python, TypeScript / JS

A project board that an LLM keeps accurate by reading what the coding agents report.

- One kanban board for all my projects. Each project repo keeps its own board; the hub only reads them.
- A commit hook refuses any commit that does not name its card, so every change links back to a card and to the agent session behind it.
- When an agent finishes a reply, Claude Haiku reads it, picks the project, then creates, moves or comments on cards. Candidate cards are found by keyword plus vector search (RAG).
- An hourly sweep links commits that name no card; cards left in review for 72 hours are accepted automatically.

Pipeline: Agent finishes a reply -> Stop hook queues the turn -> Observer LLM picks project + card operations -> Board updated, commits linked to cards -> Hourly sweep + hub sync

Stack: Python (stdlib), Static HTML + JS, RAG (embeddings + RRF), systemd timers, nginx, SQLite, Claude Haiku

### Meeting bot

- Status: Production
- For: Enterprise & operations, Product & growth
- Areas: Voice & audio, Enterprise
- Key numbers: in use at 2 companies
- Solution type: Voice & audio
- Languages: Python, TypeScript / JS

Joins a Google Meet call (Zoom supported), writes the transcript and the summary.

- Joins the call as a bot, transcribes it and tells the speakers apart.
- Writes a summary with action points and conclusions.
- Each user sees only their own meetings; several meetings run in parallel.
- Works with any models: speech-to-text and the summary model are swappable.
- In use at 2 companies.

Pipeline: Meeting link or weekly schedule -> Bot joins and records -> Speech-to-text transcript -> Diarization: who said what -> Summary: action points + conclusions

Stack: Python, TypeScript, FastAPI, Node + Playwright, Redis, PostgreSQL, Recall.ai, OpenAI-compatible STT

### RVC Global

- Status: Production
- For: Product & growth
- Areas: Products, Classification, Data & monitoring
- Key numbers: 10K+ users · 2,000+ jobs/day
- Solution type: Classification, Scraping & monitoring
- Languages: Kotlin / Java, Python, TypeScript / JS

A job search platform I co-founded in 2023: collects and classifies jobs, matches them to CVs.

- Collects jobs automatically from 60K+ sources: company ATS boards, web job boards and Telegram channels.
- Every vacancy is classified by an LLM before it reaches the board: content type, scam check, job function, work arrangement, seniority, skills, salary and geography.
- In parallel, a CV flow: the candidate uploads a CV, data points are extracted from it and saved as job preferences.
- The two flows meet in matching: rules over the classified vacancy fields and the candidate’s preferences, delivered as Telegram cards, email digests and in the web app.

Pipeline: Jobs (60K+ sources: ATS, web, Telegram; Filters + LLM classification; Published to the board) -> CVs (CV upload; Data points extracted; Saved as job preferences) -> Matching (Jobs meet candidates; Telegram · email · web app)

Stack: Kotlin, Java, TypeScript, Spring Boot, PostgreSQL, Next.js, Python + scikit-learn, AWS, Terraform

### Bank statement processing

- Status: Production
- For: Legal & finance, Enterprise & operations
- Areas: Documents, Vision & images
- Key numbers: 96.3% pages error-free
- Solution type: Extraction & OCR
- Languages: 

Statements from 5 banks in, typed transactions and a spreadsheet out.

- Reads PDF and scanned statements from 5 banks, pulls out transactions and sorts them by type.
- In production: about 60 statements a month, 7 to 10 pages each; 96.3% of pages come out with no errors.
- The public product version, Bank2XL, is a browser extension that turns statement PDFs into Excel, CSV, QBO, OFX and QFX and checks balances before export.

Pipeline: PDF or scanned statement -> OCR + text extraction -> Transactions sorted by type -> Balance check -> Excel · CSV · QBO · OFX · QFX

Stack: OCR, Browser extension

### Document processing

- Status: Production
- For: Enterprise & operations, Legal & finance
- Areas: Documents, Vision & images, Classification
- Key numbers: 400 documents a day · 91%
- Solution type: Extraction & OCR, Classification, RAG & search
- Languages: Python

Finds the document type, then reads out the fields that type needs.

- Invoices, contracts and specifications: OCR, field extraction and sorting by type.
- OCR first detects the document type; a second prompt then decides which fields to extract for that type and extracts them.
- About 400 documents a day; classifies 91% of non-standard documents correctly.
- Includes retrieval for messy PDFs: vision-based extraction, table repair, 2 embeddings per chunk, hybrid search and LLM re-ranking.

Pipeline: Incoming document -> Preprocessing -> Type detection -> Second prompt picks the fields for that type -> OCR + field extraction -> Structured data

Stack: Docling, OCR, Vision LLM

### Cold email outreach

- Status: Production
- For: Product & growth
- Areas: Outreach & GTM, Data & monitoring
- Key numbers: 25K+ contacts
- Solution type: Research & outreach, Scraping & monitoring
- Languages: Python, TypeScript / JS

From finding the company to the reply inbox, with a personal email for every contact.

- Finds app publishers on Google Play and collects 25K+ contacts, with dedup and filters by category, downloads and country.
- Researches each company before any email is written, from reviews and the web.
- Every email is personalized from that research and sent through Smartlead with delays between sends.
- A side job: setting up sending domains and mailboxes with warm-up so the emails reach the inbox.
- One inbox for replies, and A/B tests of the prompts.

Pipeline: Google Play contact lists -> Enhanced company research -> Personalized email -> Smartlead sending -> Replies in one inbox

Stack: FastAPI, React + Vite, PostgreSQL, Celery + Redis, Smartlead, OpenRouter

### AI bot for helpdesk

- Status: Production
- For: Enterprise & operations, Product & growth
- Areas: Enterprise, Classification, Knowledge & RAG
- Key numbers: every ticket classified
- Solution type: Classification, RAG & search
- Languages: Python, TypeScript / JS

Every ticket classified, enriched with account data and answered with a draft reply.

- Takes a ticket (HubSpot and others) and classifies it against the company’s standards: who is asking, category, problem type, severity and tone.
- Pulls the account data behind the ticket, such as phone, carrier, campaign and messages, and runs diagnostic checks.
- Drafts the reply and a note for support, with an escalation flag and a confidence level.
- Similar past tickets and their solutions are found by search (RAG) and shown next to the draft; analytics on top show which specialist handles which kinds of tickets.

Pipeline: Helpdesk ticket -> Classification + semantics -> Data lookup + diagnostics -> Draft reply + escalation flag -> Draft reply for support

Stack: FastAPI, Celery + Redis, PostgreSQL, RAG, Next.js, LangChain, OpenAI, HubSpot API

### Local LLM inference

- Status: Production
- For: Enterprise & operations, Developers & AI builders
- Areas: Agents & infra, Vision & images
- Key numbers: Qwen text + vision · 2 GPUs
- Solution type: Local LLMs
- Languages: 

On-premise inference with local models for several client systems.

- Local inference on 2 GPUs: Qwen text and vision models behind an OpenAI-compatible API.
- One HTTPS endpoint for all client systems, with queueing and priorities so a busy system cannot starve the others.
- Serves tender processing, bank statements, document processing, the meeting bot and classifiers.

Pipeline: Client system request -> Gateway + routing -> Priority queue + limits -> Local Qwen model -> Answer back

Stack: vLLM, Qwen, nginx, Docker

### Corporate AI chat

- Status: Production
- For: Enterprise & operations
- Areas: Agents & infra, Enterprise
- Key numbers: local network · limits + logs
- Solution type: Local LLMs
- Languages: Python

A private company AI chat with an anonymizer and an LLM proxy in front of the models.

- OpenWebUI deployed inside the company network, with sign-in through the company directory.
- An anonymizer strips names, company names and tax IDs from messages and uploaded files before they leave, and puts them back in the answer.
- An LLM proxy in front of the models: request proxying, usage monitoring, limits and logs per employee.
- Local models plus one allow-listed external provider.

Pipeline: Employee request -> Anonymizer: names, IDs, companies -> LLM proxy: limits + logs -> Provider choice: local or external -> Answer with the details restored

Stack: OpenWebUI, FastAPI, Presidio + spaCy, vLLM, Redis, LDAP

### News and event monitor

- Status: Production
- For: Enterprise & operations
- Areas: Data & monitoring, Classification
- Key numbers: digests + tags
- Solution type: Scraping & monitoring, Classification
- Languages: 

Parses chosen sources, tags every item and sends short digests.

- Parses and monitors news and events from selected sources.
- AI classifies and tags each item; the collection itself is plain parsing.
- Condenses it into digests in a fixed format, split by tags.

Pipeline: Chosen sources -> Parser collects the items -> Classifier tags each item -> Digest builder -> Tagged digest delivered

Stack: Parsers, PostgreSQL + pgvector, Local LLM

### Clarifier

- Status: Production
- For: Enterprise & operations
- Areas: Data & monitoring, Classification
- Key numbers: classify · enrich · compare
- Solution type: Classification
- Languages: 

Enriches product item cards: classification, properties and market data.

- A general-purpose product: classification and enrichment of product item cards.
- Finds each item on the market, cheaper or pricier, and pulls in text descriptions.

Pipeline: Raw product lines -> Classification -> Enrichment: properties + descriptions -> Market search: cheaper and pricier -> Enriched item card

Stack: 

### Price and product search

- Status: Production
- For: Enterprise & operations
- Areas: Data & monitoring
- Key numbers: no AI needed · AI optional
- Solution type: Scraping & monitoring, Plain software, no AI
- Languages: Python

Stock and prices from chosen suppliers, plus search for matching products.

- Parses availability and prices from a fixed list of favorite suppliers. In production, deliberately mechanical: no AI is needed.
- Product search is a working prototype: it finds an item by part number, reads the top supplier pages and writes a short report. An AI layer plugs in there.

Pipeline: Favorite suppliers -> Parser: stock + prices -> Price table -> Product search by part number -> Supplier pages to short report

Stack: Python, Flask, Web search API

### Procurement approval system

- Status: Production
- For: Enterprise & operations
- Areas: Enterprise
- Key numbers: ~1,000 users · 4K+ requests/mo
- Solution type: Plain software, no AI
- Languages: 

Every external payment of an industrial group goes through it.

- No AI, plain development.
- Owned from spec to rollout: about 1,000 users in 3 countries.
- 4,000+ requests a month; every external payment goes through it.

Pipeline: Purchase request raised -> Routed through the approval chain -> Approved or sent back -> External payment released

Stack: No AI, Plain development, ERP

### Service work orders

- Status: Production
- For: Enterprise & operations
- Areas: Enterprise
- Key numbers: 35+ sites · 1,000+ orders/mo
- Solution type: Plain software, no AI
- Languages: SQL

Field service tracked in one ERP system across many sites.

- 95% of service work is tracked in it: 35+ sites, 1,000+ orders a month.
- Enhanced maintenance plans and an equipment fleet health monitor.
- Wrote the module specifications, ran acceptance and trained the users.
- 70+ SQL reports for the business.

Pipeline: Service order -> Dispatch to a site -> Maintenance plan + work tracking -> Equipment fleet health monitor -> Closed job + reports

Stack: ERP, SQL

### Public MCP server

- Status: Production
- For: Developers & AI builders
- Areas: Agents & infra, Data & monitoring
- Key numbers: read-only tools
- Solution type: Agents & automation
- Languages: TypeScript / JS

Vacancy search that any AI assistant can call.

- A public MCP server for vacancy search: streamable HTTP, on AWS ECS Fargate.
- Two read-only tools: search jobs, and get the details of one job.
- Results are teaser cards with a link; apply contacts appear only after sign-in on the site.

Pipeline: AI assistant asks for jobs -> MCP tool: search -> Teaser job cards with a link -> MCP tool: job details

Stack: Node 22, MCP SDK, Express, AWS ECS Fargate

## Working prototypes

### BasBot

- Status: Working prototype
- For: Developers & AI builders
- Areas: Agents & infra, Knowledge & RAG
- Key numbers: per-stage models · sandbox
- Solution type: Agents & automation, RAG & search
- Languages: Python, TypeScript / JS

My own agent platform: planner, sandboxed executor, memory, and a model choice per stage.

- Requests arrive from Telegram, web and webhooks, then are classified and routed to the right topic and policy.
- Planner and executor are separate: the planner can read memory and skills but cannot call external tools. External actions wait for an operator’s approval.
- Execution runs in a Docker sandbox with no raw secrets, behind a credential proxy.
- Tiered memory with keyword, vector and graph search; a switchable model for every stage across many providers.
- About 80 skills and contract, scenario, eval and adversarial test suites.

Pipeline: Ingress: Telegram, web, webhook -> Routing + classification -> Context: memory + graph -> Planner builds the plan -> Operator approval -> Sandboxed executor + reviewer -> Delivery

Stack: Python, TypeScript, FastAPI, PostgreSQL + pgvector, RAG memory, Docker, React + Vite

### AI Company Brain

- Status: Working prototype
- For: Enterprise & operations, Developers & AI builders
- Areas: Knowledge & RAG, Voice & audio, Enterprise
- Key numbers: Meet · HubSpot · Jira
- Solution type: RAG & search
- Languages: Python, TypeScript / JS

Meetings, tickets and CRM joined into one place that answers questions and lists action points.

- Built on top of the meeting bot (an open-source Vexa fork), trimmed down to work with Google Meet.
- Connected: Google Meet meetings, HubSpot and Jira. Slack and email connectors were built but not switched on.
- Records are saved, normalized and classified, then linked into a graph across the systems. One answer window returns the answer plus action points.
- A working prototype; it did not go to production.

Pipeline: Meetings · Jira · HubSpot -> Save -> Normalize -> Classify -> Link records into a graph -> One answer window + action points

Stack: Python, TypeScript, FastAPI, Node + Playwright, Redis, PostgreSQL, Recall.ai, Docker

### Docs assistant (RAG)

- Status: Working prototype
- For: Product & growth
- Areas: Knowledge & RAG, Documents
- Key numbers: RAG · answer API
- Solution type: RAG & search
- Languages: Python

A RAG system over marketing content and an API reference, with an API that writes the answers.

- Analyzes a company’s marketing content and API documentation, and an API generates answers for users.
- Pages are cut into logical chunks by an LLM, each with tags, a category and a summary, instead of fixed-size pieces.
- Hybrid search: BM25 keyword search plus vector search, merged into one ranking.
- Answers cite their sources; off-topic and false-premise questions are refused.

Pipeline: Crawl pages + API reference -> Logical chunks + tags + summary -> Two embeddings per chunk -> Query condensing + topic guard -> Hybrid search (BM25 + vectors) + ranking -> Answer with sources

Stack: FastAPI, PostgreSQL + pgvector, BM25, OpenAI, Crawl4AI, Docker

### Lead research tool

- Status: Working prototype
- For: Product & growth
- Areas: Outreach & GTM, Classification, Data & monitoring
- Key numbers: 1,000+ companies
- Solution type: Research & outreach, Classification
- Languages: Python

Company research, scoring and personalized drafts for a marketing team.

- Starts from an ICP matrix: primary to tertiary fit, buyer personas and disqualifiers.
- Discovers 1,000+ companies by search, researches each one and scores ICP fit, buying readiness and platform fit.
- Classifies every company as hot, warm, cold or disqualified.
- Finds 3 to 5 decision makers per company and drafts personalized emails with the evidence behind each.

Pipeline: ICP matrix -> Company research + scoring -> Classification: hot, warm, cold -> Contact search -> Personalized email draft

Stack: Flask, PostgreSQL, Redis, Perplexity, Gemini, Clay

### Scan vs original check

- Status: Working prototype
- For: Legal & finance
- Areas: Documents, Vision & images
- Key numbers: up to 80 pages
- Solution type: Extraction & OCR
- Languages: Python

Compares a scanned document with its original and highlights every changed place.

- Takes the agreed original (DOCX, DOC, RTF, ODT or PDF) and the scan (PDF or an image). Works for any document type: contracts, acts with tables, specifications.
- A vision model reads each scan page and marks handwriting, signatures and stamps; suspicious places are re-read from an enlarged crop.
- Plain code, not the model, decides the verdict. Both texts are shown side by side with frames drawn on the scan.
- Found 32 of 32 planted edits with no false alarms on 37 synthetic scans. The result is a hint for a human, not a legal conclusion.

Pipeline: Original + scan uploaded -> Original parsed (DOCX to PDF) -> Vision OCR of every scan page -> Differences re-read from crops -> Verdict + side-by-side view

Stack: FastAPI, PyMuPDF, LibreOffice, Tesseract, Vision LLM, SQLite queue

### Contract review

- Status: Working prototype
- For: Legal & finance
- Areas: Documents, Knowledge & RAG
- Key numbers: clause checks + redlines
- Solution type: RAG & search
- Languages: Python, TypeScript / JS

Compares an incoming contract with the client’s own template, clause by clause.

- Once per client, the template is turned into about 40 stored criteria and reviewed by a human.
- An incoming contract is cut into logical chunks, each tagged from 28 clause types and embedded.
- Each criterion sees only the clauses it governs. The model only pulls out evidence; plain code sets the status.
- An extra-risk register catches dangerous clauses the template never expected; redlines use the template’s preferred wording; the report exports to DOCX.

Pipeline: Client template to criteria (once) -> Incoming contract to tagged chunks -> Hybrid retrieval + scope gating -> Deterministic deviation check -> Extra-risk register -> Redline + report

Stack: FastAPI, PostgreSQL + pgvector, Redis + RQ, Docling, LibreOffice

### Ad creatives optimizer (PropellerAds)

- Status: Working prototype
- For: Product & growth
- Areas: Outreach & GTM, Vision & images
- Key numbers: control panel · 6-hour sweeps
- Solution type: Agents & automation, Image generation
- Languages: TypeScript / JS

Finds weak ad creatives in PropellerAds campaigns and proposes replacements.

- A control panel over a PropellerAds account for an app marketing client.
- Every 6 hours it syncs campaign, creative and zone data and judges each creative as winner, laggard or warming, with an AI vision check.
- Proposes replacements, generates new creatives with image models and flags zones that spend without converting.
- Changes go live only after a human click.

Pipeline: Campaign stats sync (every 6 hours) -> Creative judge (AI vision) -> Laggards and dead zones flagged -> New creatives generated -> Human approval -> Live campaign change

Stack: TypeScript, Cloudflare Workers, Hono, D1, React + Vite, Gemini, Ideogram

### Call analytics

- Status: Working prototype
- For: Enterprise & operations
- Areas: Voice & audio, Enterprise, Classification
- Key numbers: speakers + checklist
- Solution type: Voice & audio
- Languages: 

Call recordings turned into transcripts, speakers and checklist-based findings.

- Transcribes call recordings and separates the speakers.
- Pulls out conclusions and scores each call against a checklist.
- Ready to run; the client has not rolled it out yet.

Pipeline: Call recording -> Transcript (speech-to-text) -> Diarization: caller and agent -> Checklist findings + conclusions

Stack: 

### Restaurant staffing + voice agent

- Status: Working prototype
- For: Product & growth
- Areas: Products, Voice & audio, Classification
- Key numbers: built in 2 weeks
- Solution type: Voice & audio, Classification
- Languages: Python, TypeScript / JS

A staffing product with a voice agent that onboards restaurant candidates and covers shifts by phone.

- Shipped the whole product in 2 weeks: backend, web app and public site.
- Restaurant side: jobs come in automatically from the public job board API (up to 2,000 a day) and scraped boards, and an LLM classifies each into a position.
- Candidate side: registration, then the voice agent’s onboarding interview by phone, then matching to jobs.
- The same agent phones candidates to cover a shift: it asks about availability, then confirms.

Pipeline: Restaurants (Jobs from job boards; LLM classifies each position) -> Candidates (Registration; Voice agent onboarding interview) -> Matching + shifts (Candidates matched to jobs; Cover calls + confirmation)

Stack: Python, TypeScript, FastAPI, PostgreSQL, React, Astro, ElevenLabs, Twilio

### Android non-custodial crypto wallet

- Status: Working prototype
- For: Product & growth
- Areas: Products
- Key numbers: 11 networks · swaps + bridges
- Solution type: Plain software, no AI
- Languages: Kotlin / Java, Python

A multi-chain wallet with swaps and bridges, first version in under 2 weeks with AI coding agents.

- Keys never leave the phone: an Android Keystore vault, biometrics and PIN, and a recovery-phrase screen protected from screenshots.
- Networks: Ethereum, Arbitrum, Optimism, Base, BNB Chain, Polygon, Avalanche, Solana, Bitcoin, TON and Tron. Send, receive, swap and bridge, with WalletConnect.
- A dedicated backend takes provider webhooks, syncs balances and transactions to a database and pushes updates to the app.
- The backend is treated as untrusted: the app re-verifies everything before it signs.

Pipeline: Wallet created and stored on the device -> Backend registers the address -> Provider webhooks to sync worker to database -> Live updates + push to the app -> Swap: backend quotes, phone verifies and signs

Stack: Kotlin, Jetpack Compose, Trust Wallet Core, Python, PostgreSQL, Firebase

### Language-learning apps

- Status: Working prototype
- For: Product & growth
- Areas: Products, Voice & audio, Vision & images
- Key numbers: ~50 teachers · 13 languages
- Solution type: Voice & audio, Extraction & OCR
- Languages: PHP, Python, TypeScript / JS

Four apps for language teachers: lesson generator, audio lessons and a handwriting check.

- Edly Pro generates lesson materials by level, age and language, with exercises and PDF export.
- Listen: a teacher picks a topic and learner level; it generates vocabulary, a text (opinions, facts or a conversation), multi-voice audio and four kinds of exercises, in 13 languages.
- Check: a student photographs handwriting; OCR, then scoring against Cambridge-style criteria with mistakes and corrections.
- Sedly combines Check and Listen under one login, with roles, progress tracking and analytics. Used by about 50 individual teachers in 2025.

Pipeline: Teacher sets topic, level and language -> Text + vocabulary generated -> Multi-voice audio (TTS) -> Exercises generated in parallel -> Handwriting: photo, OCR, scored feedback

Stack: Laravel, FastAPI, React, PostgreSQL, OpenAI GPT + TTS + Vision, Auth0

## AI stack

- Coding agents: Claude Code Max, Codex Pro, Devin, OpenCode, Droid (Factory), Cursor, Grok Heavy
- Models: Claude, OpenAI GPT, Gemini, DeepSeek, Kimi, GLM, Qwen (local), JeV (typesafe.ai), OpenRouter
- LLM frameworks: LangChain, Langfuse, MCP, Schema-guided reasoning (SGR), Pydantic structured output, own agent runtime, GEPA (prompt optimization)
- Retrieval: pgvector, BM25 + vector hybrid search, FAISS, re-ranking
- Voice and vision: Whisper, ElevenLabs, Twilio, PaddleOCR, Tesseract, Docling, vision LLMs, YOLO
- Local inference: vLLM, Ollama, quantized Qwen

## Contact

- Email: sntpeter@gmail.com
- Telegram: https://t.me/dima_rvc
- GitHub: https://github.com/maketeamake
- Site: https://neurocraft.space/