Skip to content
← All work

Multi-agent tender & RFP response platform

Bidvera

Autonomous multi-agent platform that reads enterprise tender packs, drafts evidence-grounded responses in parallel, prices the bid and produces Word/PDF dossiers, with a human sign-off gate.

My role: Design and full-stack development: agent graph, MCP servers, API, UI, document engine and evaluation

Discuss a similar project
  • LangGraph
  • FastMCP
  • Python 3.12
  • Next.js 16
  • Evals
Screenshot of Bidvera, multi-agent tender & rfp response platform, built by Anshuman Verma

Overview

Bidvera automates the high-stakes, deadline-driven work of responding to government and enterprise RFPs for IT services. Instead of a brittle chain of prompts, proposal generation is a resilient state graph: requirements are extracted and sections drafted in parallel, every claim is grounded in verified company case studies, pricing follows deterministic rate-card formulas, and an executive signs off at the bid/no-bid milestone before anything is submitted.

The challenge

Responding to an enterprise or government RFP means reading hundreds of pages, finding every mandatory requirement, checking eligibility, writing tailored sections backed by real past work, pricing the bid and assembling a formal dossier, usually against a tight deadline. Missing one mandatory clause can disqualify the whole bid.

Single-prompt AI tools are too fragile for this: they skip requirements, invent credentials and cannot be paused for a go/no-go decision. Bidvera needed to be thorough, grounded in verified company facts, fast through parallelism, and controlled by the people who sign the bid.

How it works

  1. 1Tender pack
  2. 2Parallel extraction
  3. 3Eligibility check
  4. 4Bid/no-bid approval
  5. 5Parallel drafting + pricing
  6. 6Word & PDF dossier

Architecture

Bidvera runs on a LangGraph StateGraph whose BidState holds bid metadata, requirements, the outline, pricing and the compliance matrix. Send-based fan-out runs requirement extraction across documents and drafting across sections in parallel. At the bid/no-bid milestone the graph calls interrupt(); an executive reviews and the run continues with Command(resume=...), with comments and decisions saved in durable checkpoints that survive restarts.

Tools live in four isolated FastMCP servers speaking JSON-RPC 2.0: tender-search for discovery, company-knowledge for verified case studies and CVs, pricing for rate-card calculations, and documents for final artifact generation. Drafts must cite company knowledge, and pricing is calculated deterministically. Documents are parsed with pdfplumber, PyPDF2 and Docling, and dossiers are produced with python-docx, including styled tables and compliance matrices, then converted to PDF.

The FastAPI backend streams graph execution over Server-Sent Events to a Next.js 16 and React 19 workspace with step inspection, qualification status and document previews. A floating copilot answers questions about SLAs and penalties with page citations, redrafts sections on request, and manages bids. A Pytest benchmark harness runs gold RFP datasets to check extraction recall, eligibility accuracy, hallucinations and prompt-injection resistance.

What I built

Parallel multi-agent drafting

A LangGraph StateGraph tracks bid metadata, requirements, outline, pricing and compliance; Send-based fan-out runs requirement extraction and section drafting concurrently, cutting proposal turnaround by over 70%.

Four FastMCP servers

Isolated Model Context Protocol services for tender search, company knowledge (verified case studies and CVs), pricing from rate cards, and document generation.

Bid/no-bid approval gate

LangGraph interrupt() pauses at qualification; an executive review resumes the run with Command(resume=...), and comments and decisions are saved in durable checkpoints.

Evidence-grounded answers

Responses cite verified company knowledge only, and a copilot answers questions about SLAs and penalties with page citations and redrafts sections on reviewer feedback.

Publication-ready dossiers

Formatted Word documents with styled tables and compliance matrices, converted automatically to printable PDF.

Measured, not assumed

A benchmark harness on gold RFP datasets checks extraction recall, eligibility accuracy, hallucinated facts and resistance to prompt-injection traps.

Engineering decisions

  • Model the proposal as a state graph with parallel fan-out rather than a sequential prompt chain, so it is faster and recovers from failures.
  • Keep pricing in deterministic formulas over rate cards, never in the model's head.
  • Split tools into four isolated MCP servers so search, knowledge, pricing and documents can evolve and be secured separately.
  • Persist graph state to disk so an approval can wait across restarts.

Results

  • Proposal turnaround reduced by over 70% through parallel extraction and drafting.
  • On the gold RFP benchmark: 100% extraction recall and 100% eligibility accuracy.
  • Zero hallucinated facts and all prompt-injection traps defended in the evaluation suite.
  • Publication-ready Word and PDF dossiers with compliance matrices.

Stack

Agents
LangGraph (StateGraph, Send fan-out, interrupt/resume), LangChain Core, Pydantic v2
Tools
FastMCP (tender-search, company-knowledge, pricing, documents), JSON-RPC 2.0
Backend
Python 3.12, FastAPI, Uvicorn, Server-Sent Events, durable disk checkpointer
Frontend
Next.js 16 (App Router), React 19, TypeScript, Tailwind CSS
Documents
python-docx, docx2pdf, PyPDF2, pdfplumber, Docling
Quality
Pytest benchmark harness: extraction recall, grounding checks, prompt-injection traps

Related services

Need something like this?

I can build a version of this for your product, your data and your stack.

Start a project