mcpField
M
MCP Servers Multi-Agent AI Infrastructure

MCP Servers Multi-Agent AI Infrastructure

Local
github.com/FrankGenGoAI & Agents0Updated 84w ago
Repository

About MCP Servers Multi-Agent AI Infrastructure

A modular infrastructure for building multi-agent systems with MCP servers, a Qdrant-backed semantic search service, Docker networking, and an interactive inspector for development and debugging.

Key features

  1. 01Interactive MCP server inspection dashboard
  2. 02Qdrant vector storage and semantic search
  3. 03Shared Docker network and service discovery
  4. 04Tools for monitoring agent interactions

Use cases

  1. 01Build multi-agent systems with shared capabilities
  2. 02Add semantic document search for agents
  3. 03Inspect and test MCP servers during development

MCP support

Provides a Qdrant-integrated MCP server for semantic search, plus an inspector that connects to MCP servers to explore tools, test prompts and invocations, and debug responses.

Configuration

Local server config is the same for every client. Copy it into your client’s MCP config file.

mcp.json · Universal config
{
  "mcpServers": {
    "servers-frankgengo": {
      "command": "docker",
      "args": [
        "run",
        "-i",
        "--rm",
        "build"
      ]
    }
  }
}
Run commanddocker run -i --rm build

Local servers need a runtime on your machine (e.g. Node.js 18+). Config file locations differ by client; see your client’s docs.

Packages
ocibuild

Tools

No tool list yet

Local servers expose tools only once running on your machine, and the maintainer has not provided a tool list.

Details

From the project README

MCP Servers Multi-Agent AI Infrastructure

A comprehensive infrastructure for enabling multi-agent AI swarms powered by specialized Model Context Protocol (MCP) servers. This monorepo contains the full stack of components needed to orchestrate, connect, and empower intelligent agents with various specialized capabilities.

🌟 Overview

This project enables the creation of a multi-agent AI ecosystem where specialized agents can collaborate, share context, and leverage different capabilities through the Model Context Protocol (MCP). By providing a standardized communication layer, agents can seamlessly access vector databases, specialized tools, and various data sources through a unified protocol.

The infrastructure supports:

  • Semantic search and retrieval through vector embeddings
  • Multi-agent collaboration and communication
  • Modular, microservice-based architecture
  • Visual inspection and debugging of agent interactions
  • Extensible tool frameworks for AI capabilities

🧩 Core Components

Inspector

An interactive dashboard for monitoring, testing, and debugging MCP servers. Built with React/Vite frontend and Express backend.

  • Located in: /inspector
  • Features:
    • Real-time connection to any MCP server
    • Interactive exploration of available tools
    • Test prompts and tool invocations
    • Monitor agent interactions
    • Debug server responses and behavior
Qdrant-DB with MCP Integration

Vector database implementation using Qdrant with full MCP server integration, enabling semantic search capabilities for AI agents.

  • Located in: /qdrant-db
  • Features:
    • Vector embeddings for semantic similarity search
    • Document storage with metadata
    • Python client for advanced operations
    • FastEmbed integration for efficient embeddings
    • Seamless connection to the MCP ecosystem
MCP Docker Network

Infrastructure for orchestrating and connecting MCP services in a unified network.

  • Located in: /mcp-docker-network
  • Features:
    • Isolated network for secure service communication
    • Management tools for container orchestration
    • Service discovery within the swarm
    • Simplified deployment of complex agent systems

🚀 Getting Started

Prerequisites
  • Docker and Docker Compose
  • Node.js (for local development)
  • Python 3.9+ (for running clients and scripts)
Quick Start

  1. Clone the repository:

    git clone https://github.com/FrankGenGo/mcp-servers.git
cd mcp-servers

  2. Set up the shared Docker network:

    cd mcp-docker-network
./scripts/manage-network.sh create

  3. Start the Qdrant vector database and MCP server:

    cd ../qdrant-db/qdrant_stack
docker-compose up -d

  4. Start the Inspector dashboard:

    cd ../../inspector
docker build -t mcp-inspector .
docker run -d --name mcp-inspector --network mcp-docker-network -p 5173:5173 -p 3000:3000 mcp-inspector

  5. Access the Inspector dashboard at http://localhost:5173

🏗️ Architecture

This project implements a distributed microservices architecture centered around the Model Context Protocol:

┌───────────────┐     ┌───────────────┐     ┌───────────────┐
│   AI Agent    │     │  AI Agent     │     │  AI Agent     │
│  Capabilities │     │  Reasoning    │     │  Planning     │
└───────┬───────┘     └───────┬───────┘     └───────┬───────┘
        │                     │                     │
        │                     ▼                     │
        │             ┌───────────────┐             │
        └────────────►  MCP Network   ◄─────────────┘
                     │ Communication  │
                     └───────┬───────┘
                             │
              ┌──────────────┴──────────────┐
              │                             │
    ┌─────────▼──────────┐        ┌─────────▼──────────┐
    │   Qdrant MCP       │        │  Inspector         │
    │   Vector Search    │        │  Monitoring        │
    └────────────────────┘        └────────────────────┘

Components communicate over a shared Docker network, with:

  • Inspector dashboard (port 5173) → Express proxy (port 3000) → MCP servers
  • Qdrant MCP server (port 8000) → Qdrant database (port 6333)
  • All services connected via the mcp-docker-network

🧠 Use Cases

  • Multi-Agent Systems: Build collaborative agent systems that combine different AI capabilities
  • Knowledge Management: Create semantic search systems with intuitive AI interfaces
  • Tool Integration: Extend AI capabilities with specialized tools and data sources
  • Development & Debugging: Inspect and test MCP servers during development

🛠️ Development

Each component can be developed independently:

  • Inspector: React/TypeScript frontend with Express backend
  • Qdrant MCP Server: Python FastMCP implementation
  • Network Management: Bash scripts and Docker Compose configurations

See the README in each subdirectory for specific development instructions.

📚 Further Resources

📄 License

This project is licensed under the MIT License - see the LICENSE file for details.

Comments

Markdown supported

New to MCP?

From what the protocol is to installing your first server, these answers cover most first questions.

An open protocol that defines how AI applications connect to external tools and data in a uniform way. Clients talk to the model; MCP servers provide tools, resources and prompt templates. They exchange standard messages, so one server can be reused by many clients.