法律助手代理服务

MCP Legal Assistant

Five legal-assistant agents — contract review, case research, document drafting, deadline tracking and billing — behind an authenticated FastAPI service and an MCP server, on LangGraph and LangChain, with an offline test suite and a container that boots without credentials and says what it is missing.

On the claims. The previous README ("LexPilot") promised to "automate 80% of legal grunt work", a table of hours saved ("4–6 hours → 15 minutes"), "verified citations", "no hallucinations" and "20+ document types". Nothing in this repository measures any of that; the agents are prompts over a model and every output carries a disclaimer that a licensed attorney must review it. Those claims are gone. Where a number appears here, the command that produced it appears beside it.

What runs

flowchart TD
    C[Caller] -->|X-API-Key| API[FastAPI · src/server/server.py]
    M[MCP client] -->|stdio| MCP[MCP server · src/mcp/server.py]
    API --> ORCH[Orchestrator · LangGraph]
    ORCH --> CLS{task_classifier<br/>intent verbs, then topic nouns}
    CLS --> CR[Contract reviewer]
    CLS --> RS[Case researcher]
    CLS --> DD[Document drafter]
    CLS --> DL[Deadline tracker]
    CLS --> BL[Billing calculator]
    API --> CR & RS & DD & DL & BL
    MCP --> CR & RS & DD & DL & BL
    CR & RS & DD & DL & BL -->|built on first use| LLM[src/llm.py · Anthropic or OpenAI<br/>503 until a key is configured]
    RS -.->|optional| PC[(Pinecone)]
    classDef gate fill:#fef3c7,stroke:#d97706
    class CLS,LLM gate

Each agent is a prompt, a model and a JSON parser (prompt | llm | JsonOutputParser()), followed by validation into the Pydantic models in src/models.py. The orchestrator classifies a free-text task by its verbs of intent before its topic nouns (ADR 0002) and runs the matching agent. The MCP server exposes the same five agents as tools over stdio for a local client.

What was fixed

Reproduced on the original code before each fix; every row has a test or a CI probe.

In the pull request

In the follow-up (2026-09-06)

Quick start

git clone https://github.com/daniellopez882/Legal-Assistant-Agent-with-MCP.git
cd Legal-Assistant-Agent-with-MCP
cp .env.example .env            # set API_KEY; add a model key when you have one
python -m venv .venv && .venv/bin/pip install -r requirements.txt
.venv/bin/pytest --no-cov
.venv/bin/python main.py serve  # http://127.0.0.1:8000

With no model key the service boots, /health answers, /ready is 503 naming the missing provider, and every agent route answers 503. With a key:

curl -s -H "X-API-Key: $API_KEY" -H 'Content-Type: application/json' \
  -d '{"document_text":"...","document_name":"nda.txt","matter_id":"M-1","client_name":"Acme","jurisdiction":"Texas"}' \
  http://127.0.0.1:8000/api/v1/contract/review

Container:

API_KEY=$(python -c "import secrets; print(secrets.token_urlsafe(32))") docker compose up --build

The image runs with ENVIRONMENT=production and refuses to start with the placeholder key. The MCP server is python main.py mcp (stdio).

API

Everything under /api/v1 requires X-API-Key.

Every agent response carries legal_disclaimer: the output is AI-assisted analysis for a licensed attorney to review, not legal advice.

Configuration

See .env.example.

Testing

pytest --no-cov

129 tests, all offline (129 passed, 2 skipped on 2026-09-06; the two skipped need live credentials and are deselected without them). The suite was 26 passing and 9 failing before the pull request, 90 after it. It covers the routing table exhaustively, the model factory and its placeholder handling, boot without credentials, authentication on every agent route, the production refusal, CORS, that no route echoes an exception, the parser fixes, the console scripts and the declared dependencies.

Security

Implemented: constant-time API key on every agent route; production refuses the placeholder key; CORS from configuration; no exception text in responses; non-root two-stage container that boots without secrets; bandit and pip-audit in CI; models never built from placeholder keys.

Not implemented: per-user identity (one shared key), rate limiting, an audit log of who submitted which document, and any redaction before a document is sent to a model provider. The threat model lists what remains open: docs/threat-model.md.

Limitations

• Client documents go to a third-party model provider by design. Which provider is configuration; what they do with the text is your agreement with them.
• Outputs are advisory. The prompts instruct the agents to flag and not advise; the disclaimer is on every response. Nothing verifies a citation.
• Routing is lexical. An unrecognised request falls to case research.
• The database models are unused. src/database.py is imported by nothing; docker-compose.yml no longer starts a Postgres for it.
• Pinecone is untested. The case researcher uses it when configured; no test exercises that path.
• The MCP server returns exception text to its local, same-user client.

Roadmap

1. A user store, then per-user tokens, then an audit log of submissions
2. Persistence for matters and deadlines, using the models that exist
3. A citation check against a real source before a memo is returned
4. Redaction of party names before documents leave for a provider
5. An evaluation set for each agent, scored by something other than the model

Documentation

Repository layout

.github/workflows/ci.yml   lint · tests · hermetic-suite guard · bandit · pip-audit · image build, boot and probes
main.py                    CLI: serve, mcp, review-contract, research, draft, templates
src/
  server/server.py         FastAPI app: probes, X-API-Key, agent routes, error mapping
  mcp/server.py            MCP stdio server exposing the five agents as tools
  agents/                  contract_reviewer, case_researcher, document_drafter, deadline_tracker, billing_calculator
  orchestrator.py          LangGraph workflow; routes through task_classifier
  task_classifier.py       intent verbs, topic nouns, explicit tie order
  llm.py                   get_chat_model, LazyChatModel, placeholder detection
  auth.py                  require_api_key
  config.py                typed settings; production validation
  pdf_parser.py            PDF, DOCX and text extraction
  models.py                Pydantic request/result models
  database.py              SQLAlchemy models (unused)
  vector_store.py          Pinecone (optional)
tests/                     129 offline tests
docs/                      ADRs, threat model
Dockerfile · docker-compose.yml · .dockerignore