# mcp-langchain-agent

A **Model Context Protocol (MCP) server** exposing a small set of tools, paired with a **LangChain agent** that uses those tools to complete multi-step tasks.

> 📌 **What this proves to a recruiter:** I can build agentic systems — tool use, MCP, multi-step planning — extending the kind of MCP server work happening on Adobe AEM today.

## What's in here

```
mcp-langchain-agent/
├── mcp_server/          # MCP server that exposes tools via stdio
│   ├── server.py        #   entrypoint, registers tools
│   ├── tools.py         #   the actual tool implementations
│   └── schemas.py       #   JSON schemas for tool inputs/outputs
├── agent/
│   ├── client.py        #   LangChain agent that connects to the MCP server
│   └── chains.py        #   reusable prompt/chain definitions
├── tests/
│   ├── test_server.py
│   └── test_agent.py
└── examples/
    └── run_demo.py      #   end-to-end demo of the agent solving a task
```

## The tools

The MCP server exposes three tools an LLM can call:

| Tool | What it does |
|---|---|
| `search_docs(query, top_k)` | BM25-ish keyword search over a local corpus of markdown notes |
| `get_doc(doc_id)` | Fetch the full text of a doc by id |
| `summarize(doc_id, max_words)` | Returns a short summary of a doc (LLM-backed) |

## The agent

The LangChain agent:
1. Receives a user task in natural language (e.g. *"Find what our handbook says about vacation policy and give me a 3-bullet summary"*)
2. Decides which tools to call, in what order
3. Calls the tools via the MCP client
4. Synthesises the answer from the tool outputs

Powered by `langchain-mcp-adapters` so the MCP tools become LangChain `Tool` objects — no glue code.

## Quickstart

### Prerequisites
- Python 3.11+
- An OpenAI or Anthropic API key

### Install
```bash
git clone https://github.com/adityapal26may/mcp-langchain-agent
cd mcp-langchain-agent
python -m venv .venv && source .venv/bin/activate
pip install -r requirements.txt
```

### Configure
```bash
export OPENAI_API_KEY=sk-...
# or
export ANTHROPIC_API_KEY=sk-ant-...
```

### Run the demo
```bash
python examples/run_demo.py
```

## Architecture

```
┌──────────────────┐         ┌────────────────────┐
│  LangChain Agent │ ──────▶ │  MCP Server (stdio)│
│   (client.py)    │  tools  │   (server.py)      │
└──────────────────┘  JSON   └─────────┬──────────┘
        ▲                              │
        │                              ▼
        │                     ┌────────────────────┐
        │                     │  Tool Implementations│
        │                     │   (tools.py)        │
        │                     └─────────┬──────────┘
        │                               │
        └─────── synthesized answer ────┘
```

## Why MCP

MCP is becoming the **standard protocol for connecting LLMs to tools and data sources** — Anthropic, OpenAI, and major IDE vendors all support it. Building a server + client pair here is a direct demonstration of:
- Multi-step agentic reasoning
- Tool schema design (JSON Schema for inputs)
- Process-level service boundaries (the MCP server runs as a separate process)

## Tech Stack

- Python 3.11, FastAPI (for the HTTP wrapper demo)
- LangChain (`langchain`, `langchain-openai`, `langchain-anthropic`)
- MCP (`mcp` Python SDK, `langchain-mcp-adapters`)
- `rank-bm25` for keyword search
- `pytest` for tests

## Roadmap

- [ ] Streaming token output from the agent
- [ ] Persistent conversation memory
- [ ] Observability: log every tool call + token usage
- [ ] HTTP transport (in addition to stdio)
- [ ] Eval suite: 20+ tasks with expected tool-call sequences

## Author

Aditya Pal — [@adityapal26may](https://github.com/adityapal26may)