Lease Intelligence Server

A multi-agent system for commercial real-estate lease analysis, built with LangGraph. A supervisor routes an analyst's question to specialist agents — RAG over lease documents, live market research, and a human-in-the-loop analyst that runs code only after approval — with persistent memory and structured lease abstraction. The same capabilities are also exposed over an MCP (Model Context Protocol) server. Provider-agnostic across Azure OpenAI, AWS Bedrock, Google Gemini, and Anthropic.

What it does

• Portfolio Q&A (RAG): ask questions about a folder of commercial lease PDFs and get grounded, cited answers — or an honest "I don't know" when the answer isn't in the documents.
• Lease abstraction: extract key terms (parties, rent, term, escalation, break clause, deposit) from a lease into validated JSON via structured output.
• Market research: pull current market/vacancy/rent context from the web (Tavily).
• Analyst with approval: writes small Python for rent math and pauses for human approval before running it.
• Memory: conversations persist across restarts, keyed by thread_id (SQLite checkpointer).
• MCP server: search_leases, extract_lease_terms, project_rent exposed to any MCP host (e.g. Claude Desktop).
• Tracing: every run is traced in LangSmith.

Architecture

   User
     |
     v
   CLI  ----------------  SQLite checkpointer  (persistent memory by thread_id)
     |
     v
   SUPERVISOR  (LangGraph)  --- routes each question to one specialist ---
     |
     +--  Lease Expert       -> search_leases   (grounded RAG, cites sources)
     +--  Market Researcher  -> Tavily web search
     +--  Analyst            -> writes Python -> interrupt() for approval -> runs it
     |
     |  every specialist calls into...
     v
   core/   retrieval . abstraction . projection . ingest   (framework-neutral logic)
     |
     +-->  Chroma vector store   (Titan embeddings over the lease PDFs)
     |
     +-->  MCP server (FastMCP)  exposes the SAME core over JSON-RPC:
              search_leases, extract_lease_terms, project_rent

Key design decision — a framework-neutral core. Business logic lives once in core/ and is exposed two ways: as LangChain tools for the agents, and as MCP tools for the server. No duplication, no coupling to a framework.

Provider-agnostic. config.py picks the chat model and embeddings independently from two .env switches, so switching between Azure OpenAI (the production target), AWS Bedrock, Gemini, or Anthropic is a config change — everything else codes against LangChain's shared model interface.

Tech stack

Python 3.13 · LangGraph · LangChain · Azure OpenAI / AWS Bedrock / Gemini / Anthropic · Chroma · Tavily · Pydantic (structured output) · MCP (FastMCP) · SQLite checkpointer · LangSmith.

Setup

python -m venv .venv
.venv/Scripts/python -m pip install -r requirements.txt
.venv/Scripts/python -m pip install -e .
cp .env.example .env        # then fill in provider + LangSmith (+ Tavily) keys

Set PROVIDER and EMBEDDINGS in .env (e.g. azure, bedrock, gemini) and the matching keys. See .env.example.

Usage

# 1. Add lease PDFs to data/leases/ (or generate synthetic samples)
.venv/Scripts/python scripts/make_sample_leases.py

# 2. Ingest them into the vector store (load -> chunk -> embed -> persist)
.venv/Scripts/python -m lease_crew.ingest

# 3. Chat with the crew (memory persists under this thread_id)
.venv/Scripts/python -m lease_crew.cli my-session

# 4. MCP: run the server, or drive it with the demo client
.venv/Scripts/python mcp_server/server.py          # stdio server
.venv/Scripts/python mcp_server/client_demo.py     # client: discover + call tools
mcp dev mcp_server/server.py                        # inspect in the MCP Inspector

Project layout

lease_crew/
  config.py       provider-agnostic model + embeddings factory
  state.py        shared graph state (messages + routing)
  ingest.py       load -> chunk -> embed -> persist (Chroma)
  retrieval.py    search_leases (RAG core)
  abstraction.py  extract_lease_terms (structured output)
  projection.py   project_rent (pure math)
  tools.py        LangChain @tool adapters over core
  agents.py       the three specialist workers
  graph.py        supervisor graph + human-in-the-loop analyst
  cli.py          chat loop with persistent memory
mcp_server/
  server.py       FastMCP server (same core, over MCP)
  client_demo.py  minimal MCP client