Multi-Agent Intelligence for Procurement Decisions
Intelligent document ingestion, information retrieval, and professional drafting using multi-agent architecture.
Live Demo • Features • Architecture • Deploy
This project is deployed as a production-ready Monorepo with a decoupled frontend and backend:
| Layer | Technology | Hosting | URL |
|---|---|---|---|
| Frontend | React (Vite) + TypeScript | Vercel | [API URL] |
| Backend | FastAPI (Python) | Render | [API URL] |
| Vector DB | Qdrant (In-Memory) | Embedded | N/A |
Important: The backend runs on a Free Tier instance on Render. Please allow up to 50 seconds for the server to wake up on the first request. Subsequent requests will be fast.
This system implements a zero-persistence architecture for maximum user privacy:
- In-Memory Vector Store: The Qdrant database runs entirely in RAM. No data is written to disk.
- Ephemeral Sessions: All uploaded documents and embeddings are automatically purged when the session ends or the server restarts.
- No Tracking: We do not store, log, or retain any user data.
This design ensures that your sensitive tender documents are never persisted, making it ideal for evaluating confidential procurements.
TenderCortex is an advanced multi-agent system designed to automate the analysis and response to public tenders and procurement documents. By leveraging a multi-agent architecture with specialized domain sub-agents, the system ingests documents (PDFs), retrieves relevant context using RAG (Retrieval-Augmented Generation), and synthesizes professional, compliant responses.
The core orchestration is handled by LangGraph, ensuring a robust state machine flow that includes quality auditing and iterative refinement of answers.
- Multi-Agent Architecture: Clear separation of concerns with specialized agents for Legal, Financial, Technical, and Timeline domains.
- Intelligent Routing: Automatically classifies inquiries to route them to the most appropriate domain specialist.
- RAG Pipeline: Semantic search over ingested documents to ground answers in factual data.
- Quality Assurance: Built-in auditor agent that validates responses against quality standards before delivery.
- Iterative Refinement: Self-correction mechanism where the auditor can reject answers, triggering a refinement loop.
- Modern Stack: Built with FastAPI, React, and leading AI orchestration tools.
The system operates on a state graph that coordinates the interaction between retrieval, reasoning, and generation.
graph TD
START([Start]) --> Retrieve[Retrieve Context]
Retrieve --> Grade[Grade Documents]
Grade --> Router{Domain Router}
Router -->|Legal| Legal[Specialist: Legal]
Router -->|Technical| Tech[Specialist: Technical]
Router -->|Financial| Fin[Specialist: Financial]
Router -->|Timeline| Time[Specialist: Timeline]
Router -->|Requirements| Reqs[Specialist: Requirements]
Router -->|General| Gen[Specialist: General]
Legal --> Auditor[Auditor Check]
Tech --> Auditor
Fin --> Auditor
Time --> Auditor
Reqs --> Auditor
Gen --> Auditor
Auditor -->|Pass| END([End])
Auditor -->|Fail| Refine[Refine Answer]
Refine --> Auditor
| Component | Technology | Description |
|---|---|---|
| Orchestration | LangGraph | State machine management for multi-agent workflows. |
| LLM Inference | Groq API | Fast inference using openai/gpt-oss-120b by default (overridable via GROQ_MODEL). |
| Embeddings | HuggingFace Inference API | Cloud-based embeddings (saves RAM on free tier). |
| Backend | FastAPI | High-performance async Python framework. |
| Frontend | React + TypeScript | Modern, type-safe UI with TailwindCSS. |
| Vector DB | Qdrant (In-Memory) | Zero-maintenance vector storage for ephemeral deployments. |
| Ingestion | Docling | PDF extraction and document processing. |
/TenderCortex
├── backend/
│ ├── app/
│ │ ├── agents/ # LangGraph orchestration & sub-agents
│ │ │ ├── rfp_graph.py # Main StateGraph
│ │ │ ├── risk_sentinel # Compliance auditor
│ │ │ ├── quant # Quantitative analysis
│ │ │ └── specialists/ # 6 domain-specific agents
│ │ ├── api/ # REST endpoints (chat, documents, checklist)
│ │ ├── core/ # Config, logging, exceptions
│ │ ├── schemas/ # Pydantic request/response models
│ │ ├── services/ # RAG, LLM, embeddings, vector store
│ │ └── main.py # Application entry point
│ ├── skills/ # 8 product skills (audit, parsing, scoring...)
│ └── tests/ # Unit, BDD & integration tests
├── frontend/
│ └── src/
│ ├── components/ # ChatInput, DocumentViewer, ChecklistPanel
│ ├── hooks/ # useRFP (application state)
│ └── types.ts # TypeScript definitions
├── openspec/ # Spec-Driven Development (SDD) artifacts
│ ├── specs/ # Consolidated feature specifications
│ ├── changes/ # Active changes & archive
│ └── templates/ # Spec templates (Agent, Endpoint, Node, etc.)
├── AGENTS.md # Development constitution for AI agents
├── ARCHITECTURE.md # Technical architecture documentation
└── CLAUDE.md # Claude Code guidance
The goal of this project is to demonstrate my ability to create these Multi-Agent systems at the corporate and enterprise levels. This system is not just software; it's a scalable and autonomous workforce designed to boost your team's productivity.
- Operational Agility: Reduce tender response cycles from weeks to hours. Our agents work in parallel—parsing, retrieving, and drafting—allowing your human experts to focus purely on high-value strategy and review.
- Risk Mitigation: The dedicated Risk Sentinel and Legal Auditor agents ensure every proposal adheres strictly to your corporate compliance and risk frameworks, eliminating costly oversight errors.
- Cost Efficiency: Deploy a 24/7 digital workforce that scales instantly with demand, dramatically lowering the operational overhead of pre-sales and technical writing.
- Data-Driven Decisions: Transform your historical repository of tenders into an active knowledge asset, ensuring consistency and leveraging past successes for future wins.