# Agentic RAG (Tavily + Context7 + Qdrant)

## What it does

A knowledge base the agent builds for itself — one of several context engineering sources an agent can draw on.

RAG — retrieval augmented generation — means giving a model relevant documents to ground its answer. The usual setup loads documents into a vector store up front. **Agentic RAG turns that around:** the agent builds the knowledge base itself, deciding what is worth keeping and storing it as it works.

This uses the official [Qdrant MCP server](https://github.com/qdrant/mcp-server-qdrant). Qdrant is a vector database, and the server exposes two tools: one stores a piece of text, the other finds the most relevant stored text for a query. It runs **fully locally** — `QDRANT_LOCAL_PATH` keeps everything on disk with no separate database to run, and it embeds text with a local model, so there is no extra API key.

The agent draws on three MCP servers:

| Server | Transport | Purpose |
| --- | --- | --- |
| **Tavily** (`tavily-mcp`) | stdio via `npx` | Live web search, filtered down to `tavily_search` |
| **Context7** (`mcp.context7.com`) | streamable HTTP | Current documentation for libraries, frameworks, SDKs and APIs |
| **Qdrant** (`mcp-server-qdrant`) | stdio via `uvx` | The local vector store the agent writes to and reads from |

The script runs the two halves of RAG as two separate agents:

1. **Store** — one agent with Tavily search, Context7 and Qdrant. It researches the latest on Nvidia from the web, looks up the current OpenAI Agents SDK docs through Context7, and stores the key facts from both.
2. **Retrieve** — a second agent with **only** Qdrant, no web search and no Context7. Whatever it says, it is recalling from what the first agent stored.

## Why Context7

The model's training data has a cutoff, so its memory of a fast-moving library is stale and it will confidently invent APIs that no longer exist. [Context7](https://context7.com) is a hosted MCP server that indexes library documentation and serves the current version on demand. Two tools:

- **`resolve-library-id`** — turns a package or product name (`"openai-agents"`, `"next.js"`) into a Context7 library ID.
- **`query-docs`** — fetches up-to-date documentation and code examples for that library, narrowed to your question.

The agent's instructions route anything library-shaped to Context7 rather than to memory or to a general web search — resolve the ID first, then query the docs. Because it is a plain HTTP endpoint there is nothing to install; it is wired up with `MCPServerStreamableHttp` instead of `MCPServerStdio`:

```python
context7_params = {"url": "https://mcp.context7.com/mcp", "timeout": 60}

async with MCPServerStreamableHttp(params=context7_params, client_session_timeout_seconds=60) as docs_server:
    ...
```

Two timeouts are in play and they do different things. `timeout` inside the params is the **HTTP request** timeout; `client_session_timeout_seconds` is the **MCP session read** timeout, and it defaults to just 5 seconds — low enough that a slow docs fetch would fail, so it is raised to 60 here.

## Setup

1. **Node 22+** (Tavily runs via `npx`; Qdrant runs via `uvx`, which `uv` already provides; Context7 needs nothing installed):
   - **Windows** (PowerShell): `winget install OpenJS.NodeJS.LTS`
   - **Mac**: `brew install node`
   - **Linux / anything else**: install via your package manager or from [nodejs.org](https://nodejs.org)
2. Get a free Tavily API key at [tavily.com](https://www.tavily.com) (1,000 searches/month, no credit card; starts with `tvly-`).
3. *Optional:* get a free Context7 API key at [context7.com](https://context7.com). Context7 works anonymously — the key only raises the rate limit.
4. Copy `.env.example` to `.env` and fill in:
   ```
   OPENAI_API_KEY=sk-...
   TAVILY_API_KEY=tvly-...
   CONTEXT7_API_KEY=          # optional, leave blank to run anonymously
   ```
5. Install dependencies:
   ```
   uv sync
   ```
6. Run it:
   ```
   uv run main.py
   ```

## Notes

- **First run pauses once**, sometimes for a while: the first store or search downloads Qdrant's small local embedding model. That is why the Qdrant server gets a 120s client timeout rather than 60s.
- The vector store lives in `memory/qdrant/` (collection `knowledge`), created relative to your **working directory** — run from the project folder. Delete it to start with an empty knowledge base.
- Run the script again and step 1 adds to what is already stored rather than replacing it.
- If `CONTEXT7_API_KEY` is set, it is sent as an `Authorization: Bearer ...` header; if it is absent the header is omitted entirely and the server is used anonymously.
- The retrieve agent is deliberately left with Qdrant alone. Giving it Context7 too would blur the demonstration — you could no longer tell whether an answer came from the knowledge base or from a fresh docs lookup.
- Context7 is a **remote** server, so unlike the other two it depends on network reachability of `mcp.context7.com` rather than on a local process.
- Traces at [platform.openai.com/traces](https://platform.openai.com/traces).
- **Windows, paths with spaces:** if `npx` fails to launch, use `{"command": "powershell", "args": ["/c", "npx", ...]}` instead.