What is Mcp Project

The Model Context Protocol (MCP) is a lightweight, modular architecture designed for building context-aware AI agents. It facilitates coordination between large language models, memory systems, and toolchains, allowing agents to share context and intelligently delegate tasks.

Use cases

Use cases for MCP include lightweight testing with the CLI version, full API integration for multi-agent orchestration, context-aware conversations with persistent memory, and high-performance experimental applications using the Rust backend.

How to use

To use the MCP project, clone the repository, choose between the CLI or API versions, set up a virtual environment, install dependencies, and run the server. The CLI version is suitable for minimal local testing, while the API version supports full API interactions.

Key features

Key features of the MCP project include a modular architecture, persistent memory for context-aware interactions, tool-calling capabilities, support for both local and cloud model APIs, and interfaces for both CLI and API-based interactions.

Where to use

MCP can be used in various fields such as AI research, software development, and any application requiring context-aware AI agents that can interact with users and other systems intelligently.

🧠 Model Context Protocol (MCP)

Overview

The Model Context Protocol (MCP) is an architectural concept for coordinating interactions between large language models, memory systems, and toolchains. It allows agents (like planners, researchers, or supervisors) to share context and delegate tasks intelligently.

This repository contains an implementation of an MCP system — built in both Python and Rust — with the goal of exploring practical applications of multi-agent AI orchestration, persistent memory, and real-world tool integration.

🎯 Project Goals

• ✅ Build a modular, multi-agent architecture that can evolve over time
• ✅ Implement persistent memory for context-aware conversations
• ✅ Add tool-calling (math, file ops, mock search, time, echo)
• ✅ Support local model APIs (e.g. Ollama) and cloud APIs (e.g. OpenAI)
• ✅ Provide both CLI and API-based interfaces
• ✅ Explore both Python and Rust backends

🔀 Versions in This Repository

🧪 Setup Instructions

📁 mcp_cli — Minimal Local Testing (Python)

cd mcp_cli
python3 -m venv venv
source venv/bin/activate
pip install -r requirements.txt
python run_server.py

✅ Test via terminal
❌ No API or tools in this version

📁 mcp_api — Full API MVP (Python)

cd mcp_api
cp .env.example .env
docker build -t mcp-api .
docker run -p 3000:3000 --env-file .env mcp-api

Access:

• http://localhost:3000/docs → Swagger UI
• GET /healthz → Health check
• POST /query → Main endpoint
• ws://localhost:3000/ws → Real-time agent access

✅ Includes:

• REST + WebSocket interface
• Multi-agent routing
• Tool-calling
• Persistent memory
• Docker-ready

📁 mcp_rust_v1.3 — Rust Version with Axum

cd mcp_rust_v1_3
cargo build
cargo run

API available at http://localhost:3000

✅ Features:

• Multi-agent support
• Persistent memory (SQLite)
• Axum-based high-performance API
• CLI + HTTP input

🧭 Roadmap:

• [ ] Agent-to-Agent Messaging
• [ ] Document Retrieval (RAG)
• [ ] Front-End Interface (React or Svelte)
• [ ] Production Deployment (Fly.io, Render, Linode)
• [ ] Enhanced Memory Scope & TTL
• [ ] Shared memory and scoped goals

💡 Choosing the Right Version

📜 License

MIT License — Free to use, fork, and adapt.