AI Book Agent MCP Server

An MCP (Model Context Protocol) server that provides AI assistants with intelligent access to ML textbook content for creating accurate, source-grounded documentation. This pure Python implementation uses local models for complete privacy and cost efficiency.

Overview

This project transforms authoritative ML textbooks into a knowledge service that any MCP-compatible AI assistant can access. Using local LLMs (Qwen) and embeddings (sentence-transformers), it creates a private, cost-effective RAG system exposed via the official Python MCP SDK.

Why MCP?

Traditional Approach Limitations

Knowledge locked in a single application
Users must switch between tools
Cannot leverage AI assistants they already use
Difficult to integrate with existing workflows

MCP Server Benefits

Universal Access: Works with Claude Desktop, VS Code, and any MCP client
Workflow Integration: Use book knowledge directly in your IDE or chat
Composability: Combine with other MCP servers (filesystem, GitHub, etc.)
Future-Proof: As MCP ecosystem grows, your book agent automatically works with new tools

Architecture

┌─────────────────────┐     ┌─────────────────────┐
│   Claude Desktop    │     │      VS Code        │
│  "Explain ML drift  │     │  "Generate docs     │
│   from textbooks"   │     │   for monitoring"   │
└──────────┬──────────┘     └──────────┬──────────┘
           │                           │
           └─────────────┬─────────────┘
                         │ MCP Protocol (stdio/HTTP)
                         ▼
            ┌─────────────────────────────────────┐
            │     Python MCP Server               │
            │  (Official modelcontextprotocol/    │
            │         python-sdk)                 │
            ├─────────────────────────────────────┤
            │ MCP Tools:                          │
            │ - @mcp.tool() search_books()        │
            │ - @mcp.tool() get_chapter_content() │
            │ - @mcp.tool() generate_section()    │
            │ - @mcp.tool() cite_sources()        │
            ├─────────────────────────────────────┤
            │ RAG Components (same process):      │
            │ - EPUB Parser (ebooklib)            │
            │ - Embeddings (sentence-transformers)│
            │ - Vector Store (ChromaDB/FAISS)     │
            │ - LLM Generation (Ollama/Qwen)      │
            └─────────────────────────────────────┘

Technology Stack

MCP Framework: Official Python SDK (mcp[cli])
Language: Python 3.11+
Embeddings: sentence-transformers (all-MiniLM-L6-v2)
LLM: Ollama with Qwen 2.5 7B
Vector Store: ChromaDB/FAISS
Book Parsing: ebooklib, BeautifulSoup4
Transport: stdio (local) or HTTP (remote)

Core Features as MCP Tools

1. searchBooks

Search across all indexed books for relevant content

{
  name: "searchBooks",
  description: "Search ML textbooks for specific topics or concepts",
  inputSchema: {
    query: string,
    bookFilter?: string[],
    maxResults?: number,
    includeContext?: boolean
  }
}

2. getChapterContent

Retrieve specific chapter or section content

{
  name: "getChapterContent",
  description: "Get full content of a specific book chapter",
  inputSchema: {
    bookId: string,
    chapterId: string,
    format?: "markdown" | "plain"
  }
}

3. generateSection

Generate documentation based on book content

{
  name: "generateSection",
  description: "Generate documentation section grounded in textbook sources",
  inputSchema: {
    topic: string,
    outline?: string[],
    style?: "technical" | "tutorial" | "overview",
    maxSources?: number
  }
}

4. citeSources

Get proper citations for content

{
  name: "citeSources",
  description: "Generate proper citations for book content",
  inputSchema: {
    bookId: string,
    pageNumbers?: number[],
    format?: "APA" | "MLA" | "Chicago"
  }
}

Resources

The server exposes book content as browsable resources:

/books
├── /designing-ml-systems
│   ├── metadata.json
│   ├── /chapters
│   │   ├── /1-introduction
│   │   ├── /2-ml-systems-design
│   │   └── ...
│   └── /topics
│       ├── /monitoring
│       ├── /deployment
│       └── ...
└── /other-ml-book
    └── ...

Prompts

Pre-configured prompts for common tasks:

doc_generator

name: doc_generator
description: Generate technical documentation from book sources
arguments:
  - name: topic
    description: The topic to document
  - name: audience
    description: Target audience (beginner/intermediate/advanced)
  - name: length
    description: Desired length (brief/standard/comprehensive)

concept_explainer

name: concept_explainer
description: Explain ML concepts using textbook definitions
arguments:
  - name: concept
    description: The concept to explain
  - name: include_examples
    description: Whether to include practical examples

Use Cases

1. In Claude Desktop

User: "Explain model drift using the ML textbooks"
Claude: [Uses searchBooks tool to find drift content]
        [Retrieves relevant chapters]
        [Generates explanation with citations]

2. In VS Code

# User comment: "TODO: Add monitoring based on best practices"
# AI Assistant uses book agent to generate monitoring code

3. Documentation Pipeline

# Automated doc generation using MCP tools
mcp-client generate-docs \
  --server ai-book-agent \
  --topics "deployment,monitoring,testing" \
  --output ml-best-practices.md

Getting Started

Prerequisites

Linux system (Ubuntu 22.04+ recommended)
Python 3.11+
Node.js 18+
16GB RAM minimum
20GB free disk space

Installation

# Clone the repository
git clone <repository-url>
cd ai-book-agent

# Install Python dependencies (with MCP SDK)
pip install "mcp[cli]" sentence-transformers chromadb ollama ebooklib beautifulsoup4

# Or use requirements.txt
pip install -r requirements.txt

# Install Ollama for local LLM
curl -fsSL https://ollama.ai/install.sh | sh

# Pull required models
ollama pull qwen2.5:7b

# Index existing books
python scripts/index_books.py

Configuration

Configure the server:

# config.yaml
embeddings:
  model: "all-MiniLM-L6-v2"
  device: "cpu"  # or "cuda"
  
generation:
  provider: "ollama"
  model: "qwen2.5:7b"
  base_url: "http://localhost:11434"
  
books:
  data_dir: "data/epub"
  index_dir: "data/vector_db"

Add to Claude Desktop config:

{
  "mcpServers": {
    "ai-book-agent": {
      "command": "python",
      "args": ["/path/to/ai-book-agent/server.py"]
    }
  }
}

Basic Usage

Once configured, the tools are available in any MCP client:

You: What does the <author> say about feature engineering?
Assistant: I'll search the ML textbooks for information about feature engineering.

[Calling searchBooks with query="feature engineering"]
[Found 5 relevant sections in "<Book Title>"]

According to <author> in "<Book Title>":

Feature engineering is described as... [content with citations]

Development

Adding New Books

# Place EPUB in data directory
cp new-ml-book.epub data/epub/

# Re-index all books
python scripts/index_books.py

# Server will automatically pick up new content

Extending Tools

Add new tools directly in server.py:

from mcp.server.fastmcp import FastMCP

mcp = FastMCP("ai-book-agent")

@mcp.tool()
def compare_approaches(approach1: str, approach2: str) -> str:
    """Compare different ML approaches from multiple books"""
    results1 = search_books(approach1, 3)
    results2 = search_books(approach2, 3)
    
    comparison = generate_comparison(results1, results2)
    return comparison

@mcp.resource("book://{book_id}/summary")
def get_book_summary(book_id: str) -> str:
    """Get a summary of a specific book"""
    return load_book_summary(book_id)

Testing

# Test MCP server locally
mcp dev server.py

# Test individual components
python scripts/test_components.py
python scripts/test_search.py

# Run full test suite
pytest tests/

# Test with Claude Desktop
mcp install server.py

Project Structure

ai-book-agent/
├── server.py             # Main MCP server (entry point)
├── src/                  # Python modules
│   ├── parsers/          # EPUB parsing
│   ├── embeddings/       # Embedding generation
│   ├── search/           # Vector search & retrieval
│   ├── generation/       # LLM integration (Ollama)
│   └── utils/            # Configuration and helpers
├── scripts/              # Utility scripts
│   ├── index_books.py    # Index EPUB files
│   ├── test_*.py         # Test individual components
│   └── setup.py          # Initial setup
├── data/
│   ├── epub/             # Source EPUB files
│   ├── processed/        # Processed book content
│   └── vector_db/        # Vector store data
├── tests/                # Test suites
├── config.yaml           # Configuration
├── requirements.txt      # Python dependencies
└── README.md

Pure Python Architecture

This project uses a simplified, single-language approach:

Python MCP Server: Official SDK handles MCP protocol and tool exposure
Integrated RAG: All ML components run in the same Python process
Local Models: Complete privacy with Ollama and sentence-transformers

Benefits of this approach:

Simpler deployment: Single Python service
Direct ML access: No API overhead between MCP and RAG
Easier debugging: One codebase, one process
Better performance: No network calls between components

Remote Access

For accessing the server from anywhere:

# Option 1: Cloudflare Tunnel (recommended)
cloudflared tunnel create book-agent
cloudflared tunnel run --url http://localhost:8080 book-agent

# Option 2: Configure with your domain
# See USER_GUIDE.md for detailed setup

Roadmap

Contributing

See USER_GUIDE.md for details on:

Adding new tools
Improving search algorithms
Supporting new book formats
Performance optimizations

AI Book Agent MCP Server

AI Book Agent MCP Server

Overview

Why MCP?

Traditional Approach Limitations

MCP Server Benefits

Architecture

Technology Stack

Core Features as MCP Tools

1. searchBooks

2. getChapterContent

3. generateSection

4. citeSources

Resources

Prompts

doc_generator

concept_explainer

Use Cases

1. In Claude Desktop

2. In VS Code

3. Documentation Pipeline

Getting Started

Prerequisites

Installation

Configuration

Basic Usage

Development

Adding New Books

Extending Tools

Testing

Project Structure

Pure Python Architecture

Remote Access

Roadmap

Contributing

Reviews