MCP Reasoning Engine MCP Server

MCP Reasoning Engine with Claude Agent

A production-ready reasoning engine that combines Claude AI with Model Context Protocol (MCP) tools for structured reasoning across legal, health, and science domains.

Features

• 🤖 Claude Agent Integration: Uses Anthropic's Claude API with tool use capabilities
• 🔧 MCP Tools: Three specialized tools for knowledge search, schema validation, and rubric evaluation
• 📚 RAG Integration: Knowledge base search across domain-specific documents
• ✅ Schema Validation: Ensures structured JSON output matches required schemas
• 📊 Rubric Scoring: Domain-specific evaluation with pass/fail thresholds
• 🌐 HTTP API: RESTful API for easy integration
• 🐳 Docker Ready: Containerized deployment support

Architecture

┌─────────────────┐
│   HTTP API      │  (Optional - mcp_api_server.py)
│   or Direct     │
└────────┬────────┘
         │
         ▼
┌─────────────────┐      ┌──────────────┐
│ Claude Agent    │◄────►│  MCP Server  │
│ claude_agent.py │      │  server.py   │
└────────┬────────┘      └──────┬───────┘
         │                      │
         ▼                      ▼
┌─────────────────┐      ┌──────────────┐
│ Anthropic API   │      │ RAG Tools   │
│   (Claude)      │      │ Validators   │
└─────────────────┘      └──────────────┘

Quick Start

Prerequisites

• Python 3.8+
• Anthropic API key (Get one here)

Installation

1. Clone or extract the project

   cd reasoning_engine_mcp_demo
   

2. Create virtual environment

   python -m venv .venv
   
   # Windows
   .venv\Scripts\activate
   
   # Linux/Mac
   source .venv/bin/activate
   

3. Install dependencies

   pip install -r requirements.txt
   

4. Set API key

   # Windows PowerShell
   $env:ANTHROPIC_API_KEY = "your_api_key_here"
   
   # Linux/Mac
   export ANTHROPIC_API_KEY="your_api_key_here"
   

Usage

Option 1: Direct Python Usage

import asyncio
from mcp.claude_agent import ClaudeReasoningAgent

async def main():
    agent = ClaudeReasoningAgent()
    result = await agent.reason("Is a verbal promise enforceable?")
    print(result)

asyncio.run(main())

Option 2: Command Line

python -m mcp.claude_agent --question "Your question here"

Option 3: HTTP API Server

# Start server
python mcp_api_server.py

# Server runs on http://localhost:8000
# API docs: http://localhost:8000/docs

API Example:

curl -X POST http://localhost:8000/reason \
  -H "Content-Type: application/json" \
  -d '{"question": "Is a verbal promise enforceable?"}'

Project Structure

reasoning_engine_mcp_demo/
├── mcp/                          # MCP server and agent
│   ├── server.py                # MCP server with 3 tools
│   ├── claude_agent.py          # Claude agent with MCP integration
│   └── DEPLOYMENT.md            # Deployment guide
├── rag_docs/                    # Knowledge base documents
│   ├── legal/                   # Legal domain documents
│   ├── health/                  # Health domain documents
│   └── science/                 # Science domain documents
├── domains/                     # Domain configurations
│   ├── domain_config.json       # Domain routing config
│   ├── legal/rubric.json        # Legal rubric
│   ├── health/rubric.json       # Health rubric
│   └── science/rubric.json      # Science rubric
├── schemas/                     # JSON schemas
│   └── universal_reasoning_schema.json
├── validators/                  # Validation modules
│   ├── schema_validator.py
│   └── rubric_validator.py
├── tools_rag.py                 # RAG search implementation
├── router.py                    # Domain routing
├── mcp_api_server.py            # HTTP API server
├── requirements.txt             # Python dependencies
└── README.md                    # This file

MCP Tools

The MCP server exposes three tools:

1. search_knowledge_base(query: str)

   • Searches RAG documents for relevant information
   • Returns formatted results with source, title, and content

2. validate_reasoning_schema(output_json: str)

   • Validates JSON output against the universal reasoning schema
   • Returns validation status and errors

3. evaluate_with_rubric(domain: str, output_json: str)

   • Evaluates reasoning output against domain-specific rubric
   • Returns scores, pass/fail status, and human review flags

Domains

The system supports three domains:

• Legal: Contract law, enforceability, legal reasoning
• Health: Medical information, symptoms, safety boundaries
• Science: Scientific reasoning, hypotheses, evidence evaluation

Each domain has:

• Domain-specific RAG documents
• Custom rubric for evaluation
• Keyword-based routing

Configuration

Environment Variables

• ANTHROPIC_API_KEY (required): Your Anthropic API key
• MCP_PORT (optional): HTTP API por