Matvei Vasetsov
Analyst
13+ years exp
Python
SQL
Data Pipeline & Feature Engineering: 4/10
MLOps & Deployment: 4/10
Active 15 days ago
+7 (921) 9008618 Invite to interview
Message
Download CVCV
Overview
Technical skills
Timeline
Roles
Overview
A pragmatic LLM engineer who builds end-to-end LLM-powered services and retrieval pipelines at a solid senior level. The strongest proven skill is integrating LLMs with retrieval and persistence - evidenced by the rag_engine/embeddings + Pinecone manager and the FastAPI endpoints with audit/provider abstraction. There is little or no evidence of custom model training, experiment tracking, GPU/quantization optimization or novel research contributions in public code.
Technical skills
Python• Senior
SQL• Middle • 13y+
Python
SQLAlchemy
Alembic
aiogram
FastAPI
Databases
FAISS
Pinecone
PostgreSQL
AI/ML
OpenAI SDK
Prompt Engineering
LLM Apps
LLM
DevOps
Rest API
QA
Postman
Timeline
Quantitative Researcher and Developer
•
Middle
Self-Employed (IE)
•
Full-Time
Elicited and formalized requirements, then designed end-to-end solution architecture for a copy trading platform, including producing a full SRS specification with multiple diagram types. Built a production CRM using a Python-based web stack and managed it from requirements through deployment and operational support. Authored OpenAPI specifications for REST backends and used LLM tooling to accelerate draft documentation of requirements and design artifacts.
FastAPI
PostgreSQL
LLM
Rest APIsince 2024
Systems Analyst
•
Middle
Techcoredev.ru
•
Full-Time
Owned the full specification lifecycle for an insurance product and back-office management system. Collaborated with stakeholders and developers to formalize requirements across core business processes and produce structured documentation artifacts. Designed and documented integrations with REST endpoints and XML/JSON schemas, validating them with Postman and database tools, and performed AI-assisted reverse analysis of legacy logic to speed up design while keeping documentation maintainable.
Rest API
Postman
Lead Analyst
•
Lead
LANIT-TERCOM
•
Full-Time
Delivered end-to-end system specifications for multiple enterprise back-office projects in FinTech, GovTech, and Energy domains. Reverse-engineered a legacy utility billing system by analyzing SQL stored procedures and producing data-flow, ERD, and process mapping documentation to enable modernization. Produced user documentation and delivered knowledge-transfer for business representatives, along with system landscape documentation for executive decision-making.
SQL
Lead Analyst
•
Lead
Raccoonsoft.ru & Devexperts.com
•
Full-Time
Drove requirements elicitation and specification for an iPad trading platform across multiple asset classes. Acted as the main liaison between US-based business stakeholders and engineering teams, improving iteration speed through granular and structured specifications. Reverse-engineered client and platform components and produced integration and architecture documentation used as a baseline for the iPad client.
Business / Systems / Financial Analyst
•
Middle
Devexperts.com
•
Full-Time
Specified requirements in English for trading and broker platform components, including margin calculations and back-office and risk-management modules. Designed trading workflow specifications and quote-feed architectures aimed at high-load operation and ensured smooth production launches. Covered integrations using FIX protocol and supported business communication with development and operations teams.
Senior AI/ML Engineer
Confidence: Medium LLM Engineer
A pragmatic LLM engineer who builds end-to-end LLM-powered services and retrieval pipelines at a solid senior level. The strongest proven skill is integrating LLMs with retrieval and persistence - evidenced by the rag_engine/embeddings + Pinecone manager and the FastAPI endpoints with audit/provider abstraction. There is little or no evidence of custom model training, experiment tracking, GPU/quantization optimization or novel research contributions in public code.
Model Architecture & Training
1/10
How well models are designed and trained
No evidence of custom model training, custom architectures or training loops — only inference/wrapping of hosted LLMs and prompt-based pipelines.
Evidence
analyst-architect-ai/backend/app/services/llm_client.py: call_llm / _call_openai_compat wrappers for provider inference
FinAnalyst-Haystack-Docling-Agent/hay_v2_bot/components/tools.py: OpenAIChatGenerator usage (inference-only)
Data Pipeline & Feature Engineering
4/10
How data is prepared for models
Clear, deliberate data/ingestion pipelines and embedding handling: document chunking, tokenizer-aware chunker, embedding creation and indexing with de-duplication logic.
Evidence
FinAnalyst-Haystack-Docling-Agent/hay_v2_bot/pipelines/ingestion_pipeline.py: convert_to_chunks / ingestion pipeline construction
FinAnalyst-Haystack-Docling-Agent/hay_v2_bot/components/tools.py: build_docling_chunker (tokenizer-aware chunking)
FinAnalyst-Haystack-Docling-Agent/pinecone_manager.py: upsert_document/upsert_vectors + similarity check logic
Experimentation & Evaluation
3/10
How results are measured and tested
Good unit and integration test coverage for LLM-driven behavior and API endpoints, but no experiment tracking, runs, or reproducible experiment metadata (W&B/MLflow) present.
Evidence
analyst-architect-ai/backend/tests/test_main.py: broad pytest suite covering AI reviewer, RAG splitting and API integration
analyst-architect-ai/backend/tests/test_epic_a_diagrams.py: focused tests for diagram rendering, fallback and DOCX export
MLOps & Deployment
4/10
How models are shipped to production
MLOps & deployment evidence: FastAPI service structure, alembic migrations, provider config abstraction, audit logging and safe-local-provider enforcement for LLM calls; suitable for production deployment though not highly automated CI/CD infra shown.
Evidence
analyst-architect-ai/backend/app/main.py: FastAPI app, router wiring and lifecycle setup
analyst-architect-ai/backend/alembic/versions/0001_initial.py: full database migrations
analyst-architect-ai/backend/app/services/llm_client.py: provider config loading and multi-provider call paths; app/services/audit_service.py: with_audit wrapper recording provider provenance
Computational Efficiency
2/10
How efficiently computing resources are used
Some efficiency-minded implementation (batching summaries, batched upserts, limited de-duplication), but no GPU/quantization/flash-attention/ profiling or distributed optimization work.
Evidence
FinAnalyst-Haystack-Docling-Agent/hay_v2_bot/components/tools.py: summarization with batching to respect model token limits
FinAnalyst-Haystack-Docling-Agent/pinecone_manager.py: upsert_vectors and upsert_documents for batched writes
Research Depth & Innovation
1/10
Depth of research and new ideas
No novel research contributions or custom model components; project applies established LLM/RAG/agent patterns rather than new algorithms.
Evidence
analyst-architect-ai/backend/app/services/ai_reviewer.py: safe-fallback and prompt modes (engineering logic, not research-level new methods)
analyst-architect-ai/backend/app/services/diagram_engine.py: LLM-driven diagram generation and fallback paths (engineering reuse of LLMs)
Expertise
RAG• Senior
LLM• Middle
Industries
Artificial Intelligence• Senior
Financial Services• Middle
Technologies
SQL• Middle • 13y+
PostgreSQL
Rest API
Pinecone
FAISS
SQLAlchemy
FastAPI
LLM
Alembic
Docling• mentioned only
Haystack• mentioned only
PyTorch• mentioned only
Recommendations
- Build production RAG-backed APIs and retrieval pipelines that require auditing, RBAC and provider fallbacks (FastAPI + provider-abstraction + Pinecone/FAISS).
- Develop domain-specific chat/agent workflows and tool integrations (Haystack/Agent tooling + Telegram agents) where prompt engineering, memory and retrieval are central.
- Harden MLOps: add experiment tracking (W&B/MLflow), CI/CD for models and infra (Argo/Cloud Run), and resource-efficiency work (batching profiles, quantization) to move toward staff-level ML engineering tasks.
Repositories
The developer's experience in this domain has been verified based on AI analysis of the following repositories:
Middle Data Scientist
Confidence: Medium Data Engineer
A pragmatic mid-level developer (Middle) who builds production-grade LLM integrations, RAG pipelines and Telegram-facing agents. The strongest proven skill is engineering retrieval and ingestion pipelines with vector DB integration and deduplication logic (FinAnalyst-Haystack-Docling-Agent/pinecone_manager.py and hay_v2_bot/components/tools.py). There is limited evidence of statistical rigor, automated tests or large-scale system design in public code, and no notebooks or formal MLOps/CI pipelines were found.
Statistical Rigor
1/10
Correct use of statistics
Minimal statistical rigor: the project has simple scoring/comparison logic for prompt outputs but no statistical tests, uncertainty quantification, or experiment design evidence.
Evidence
Prompter/prompter.py: compare_all and _metrics implement a deterministic score function (no statistical tests)
Prompter/prompter.py: parse_response implements multi-stage JSON extraction but not formal validation/uncertainty analysis
Data Wrangling & Cleaning
6/10
Preparing and cleaning data
Strong evidence of practical data wrangling and ingestion work: document chunking, metadata enrichment, embedding creation and deduplication/upsert logic for a vector DB are implemented with defensive checks and error handling.
Evidence
FinAnalyst-Haystack-Docling-Agent/pinecone_manager.py: create_embedding, _check_similarity, upsert_document/upsert_vector with similarity-check/update logic
FinAnalyst-Haystack-Docling-Agent/hay_v2_bot/components/tools.py: MetadataEnricher and build_docling_chunker (Docling → chunks → tiktoken-sized tokenization)
FinAnalyst-Haystack-Docling-Agent/hay_v2_bot/pipelines/ingestion_pipeline.py: ingestion pipeline signatures and converter/convert_to_chunks integration
Exploratory Analysis & Visualization
1/10
Exploring and visualizing data
Exploratory/visual work is minimal and mostly operational (logs, previews); there are no structured EDA, analytic visualizations or narrative data storytelling artifacts.
Evidence
hay_v2_bot/bot/telegram_bot.py: logged previews of retrieved chunks and simple debug output of matches
Prompter/prompter.py: print_comparison/write_artifact produce textual markdown reports (tables), but not analytic visualizations
Predictive Modeling
1/10
Building models that predict
No predictive modeling or ML training pipelines are present; the code orchestrates LLM/embedding API calls and scoring of prompt outputs rather than building/train/evaluate ML models.
Evidence
Prompter/prompter.py: orchestrates OpenAI/LLM calls via openai_client.chat and scores responses (no model training/feature engineering)
FinAnalyst-Haystack-Docling-Agent/pinecone_manager.py: embedding creation via OpenAI embeddings API (inference-only, no model training)
Business Insight & Impact
4/10
Turning analysis into business value
Clear business focus on conversational AI for finance: the code integrates financial data tools, designs user-facing flows (Telegram), and generates actionable RAG responses, but it lacks formal business-metric instrumentation or documented error-cost tradeoffs.
Evidence
FinAnalyst-Haystack-Docling-Agent/README.md: explicit product framing as a financial Telegram assistant with RAG + Pinecone
FinAnalyst-Haystack-Docling-Agent/hay_v2_bot/components/tools.py: AlphaVantageFinancialFact and AlphaVantageRandomImage implement finance-specific tools and structured outputs
FinAnalyst-Haystack-Docling-Agent/hay_v2_bot/bot/telegram_bot.py: user flows for document ingestion, summarization and financial chart analysis
Reproducibility & Notebook Hygiene
3/10
Clean, repeatable analysis
Reasonable reproducibility for a script-based project: requirements files, saved artifacts and session persistence are present, but there is no pinned environment file, CI, tests, or data versioning demonstrated.
Evidence
Prompter/requirements.txt: explicit dependency list for the prompter CLI
Prompter/ai_direct.py: SESSION_FILE = "session.json" shows session persistence (save/restore patterns)
Prompter/prompter.py: write_artifact and save_markdown produce reproducible markdown artifacts for runs
Expertise
Analytics• Middle
Big Data• Middle
Industries
Artificial Intelligence• Senior
Financial Services• Middle
Technologies
LLM Apps
Python• Senior
Prompt Engineering
OpenAI SDK
aiogram
Docling• mentioned only
Haystack• mentioned only
Pinecone• mentioned only
PyTorch• mentioned only
Recommendations
- Develop RAG-enabled conversational agents and document-ingestion pipelines that use Haystack/Docling + Pinecone (build on hay_v2_bot and pinecone_manager.py).
- Build production prompt-engineering toolchains and A/B evaluation dashboards (extend Prompter/prompter.py and artifact generation into CI/automation).
- Integrate and harden multi-provider LLM orchestrations (openai_client + provider selection) into deployable microservices or serverless functions.
- Implement reproducibility and quality gates: add unit/integration tests, CI, pinned envs and data/versioning (move write_artifact into a reproducible pipeline).
Repositories
The developer's experience in this domain has been verified based on AI analysis of the following repositories:
Middle Backend Developer
Confidence: Medium API Engineer
A pragmatic backend API engineer at a middle level who builds full-stack services and integrations. The strongest proven skill is building LLM-backed backend services and safe parsing/validation for AI integrations, demonstrated by artifacts in artifacts/api-server/backend/services/ai_service.py and related routers. The public codebase shows solid API, DB and real-time/trading pieces but lacks evidence of large-scale production hardening (SLI/SLOs, exhaustive resilience policies and measured performance tuning).
API Design
5/10
How well APIs are designed
Consistent REST-first design with FastAPI routers, OpenAPI exposure and a generated TypeScript API client; sound error handling patterns on client side but no explicit idempotency/key strategies or formal versioning.
Evidence
MatveiV/Analyst-Guru/artifacts/api-server/backend/main.py: FastAPI app, docs/openapi configured and many routers included
MatveiV/Analyst-Guru/lib/api-client-react/src/generated/api.ts: generated client hooks for API endpoints
MatveiV/Analyst-Guru/lib/api-client-react/src/custom-fetch.ts: ApiError/ResponseParseError and robust client-side error handling
Data Layer & Database
5/10
Working with databases
Clear relational schema and ORM usage, alembic and manual migration scripts are present; transaction usage and isolation-level tuning not explicit, but migration/seed scripts and model relationships are implemented.
Evidence
MatveiV/Analyst-Guru/artifacts/api-server/backend/models.py: SQLAlchemy models with relationships and constraints
MatveiV/Analyst-Guru/artifacts/api-server/alembic/env.py: alembic env configuration for migrations
MatveiV/OrdersCRM/backend/scripts/migrate_applications.py: explicit SQL migrations and seeding logic
Scalability & Performance
4/10
Handling load and speed
Evidence of concurrency and async design for real-time/trading workloads and async DB usage; limited evidence of caching strategies, connection-pool tuning or measured load optimization.
Evidence
MatveiV/TradingRobotMarketplace/backend/app/robot_manager/manager.py: asyncio-based background monitoring, locks, periodic tasks
MatveiV/OrdersCRM/backend/app/core/database.py: asyncpg / SQLAlchemy asyncio engine usage
MatveiV/Analyst-Guru/artifacts/api-server/backend/services/rag_engine.py: embedding/indexing interface (RAG) suggesting vectorized retrieval pipeline
System Architecture
5/10
Overall system structure
Reasonable module and service decomposition (api layer, services: ai, rag, audit, db models, generated client libraries) and deliberate separation of concerns; architecture is monorepo but components are separated by responsibility.
Evidence
MatveiV/Analyst-Guru/artifacts/api-server/backend/services/ai_service.py: dedicated AI integration service
MatveiV/Analyst-Guru/artifacts/api-server/backend/api/: multiple routers (documents, reviews, kb, generators, memory, diagrams, audit)
MatveiV/Analyst-Guru/lib/api-client-react: codegen and generated client indicate API-contract-first thinking
Security & Auth
5/10
Protecting data and access
Practical security patterns present - JWT flows, password hashing, environment/DB-backed API key selection, and input validation via Pydantic; secrets handling could be tightened (env defaults) and CORS is permissive.
Evidence
MatveiV/OrdersCRM/backend/app/core/security.py: JWT access/refresh token helpers and password hashing
MatveiV/Analyst-Guru/artifacts/api-server/backend/services/ai_service.py: _load_ai_settings reads API keys from DB/env and validates provider selection
MatveiV/Analyst-Guru/artifacts/api-server/backend/main.py: CORS configured (allow_origins=["*"])
Reliability & Observability
5/10
Stability and monitoring
Logging, structured error pathways and fallback behaviours are implemented (LLM fallbacks, ApiError on client); testing artifacts exist for many endpoints, but advanced reliability patterns (backoff with jitter, circuit breakers, documented SLIs) are not visible.
Evidence
MatveiV/Analyst-Guru/artifacts/api-server/backend/services/ai_service.py: safe_fallback_review/safe_fallback_answer, logging and error handling around LLM calls
MatveiV/Analyst-Guru/artifacts/api-server/tests/: multiple tests for endpoints (documents, diagrams, generators, kb, memory, reviews)
MatveiV/Analyst-Guru/lib/api-client-react/src/custom-fetch.ts: Response parsing errors and ApiError for observability of client failures
Expertise
Backend AI & LLM• Middle
Python• Middle
Databases & Vector Storage• Middle
Messaging & Real-time• Middle
Microservices & API Architecture• Middle
Recommendations
- Lead implementation of LLM-backed internal tools or RAG services - ownership of ai_service + rag_engine style components
- Develop backend API endpoints and contract-first client generation (OpenAPI + generated TypeScript clients)
- Implement real-time or trading system features that need async concurrency and risk-management (robot_manager / broker adapters)
- Harden production concerns: add retries/backoff with jitter, circuit breakers, metrics (SLIs), and secrets management
Repositories
The developer's experience in this domain has been verified based on AI analysis of the following repositories: