Skip to main content
Glama

Ultimate MCP Coding Platform

by Senpai-Sama7
GitHub
Python
MIT License
OverviewInspectNewEndpointsSchemaRelated ServersReviewsScore
Need Help?View Source CodeReport Issue

Ultimate MCP Coding Platform

CI

Ultimate MCP is a production-ready Model Context Protocol platform that turns any LLM into a coding co-pilot. It ships with a FastAPI + FastMCP backend, Neo4j graph persistence, OpenAI Agent integration, a React frontend, and Docker Compose orchestration.

Features

  • Real MCP server with lint, test, execution, generation, and graph tools

  • Neo4j persistence for tool artefacts with aggregation metrics

  • REST API mirroring MCP tools and secured by bearer token + rate limiting

  • Structured logging, strict CORS, security headers, and per-request IDs

  • React + Vite frontend for human operators

  • OpenAI Agents SDK bridge for autonomous tool discovery and execution

  • Complete CI pipeline (lint, type-check, tests with coverage, Docker builds)

  • Docker Compose for one-command local deployment

Repository Layout

backend/ FastAPI MCP server and tool implementations frontend/ React TypeScript application scripts/ Developer automation (setup & smoke tests) deployment/ Docker Compose specification docs/ Architecture, API, security, and operations guides

Quickstart

1. Dependencies

  • Python 3.13+

  • Node.js 20+

  • Docker & Docker Compose (for containerised runs)

2. Bootstrap Environment

scripts/setup.py

This creates backend/.venv, installs Python requirements, and runs npm install for the frontend.

3. Run Locally (Developer Mode)

Backend:

source backend/.venv/bin/activate uvicorn mcp_server.server:app --reload

Frontend:

cd frontend npm run dev -- --host 0.0.0.0 --port 3000

Open the UI at http://localhost:3000. The API docs live at http://localhost:8000/docs.

4. Run with Docker Compose

cp .env.example .env # set AUTH_TOKEN before production use docker compose -f deployment/docker-compose.yml up --build

Expose:

  • Frontend: http://localhost:3000

  • API: http://localhost:8000

  • Neo4j Browser: http://localhost:7474

Testing

# lint & type-check backend/.venv/bin/ruff check backend backend/.venv/bin/mypy backend # run pytest with coverage NEO4J_URI=bolt://localhost:7687 \ NEO4J_USER=neo4j \ NEO4J_PASSWORD=password123 \ AUTH_TOKEN=test-token \ backend/.venv/bin/pytest backend/tests --cov=backend/mcp_server --cov=backend/agent_integration --cov-report=term-missing --cov-fail-under=80 # frontend lint + build cd frontend npm run lint npm run build

A ready-made smoke test hits key endpoints:

scripts/smoke_test.py --base-url http://localhost:8000

MCP & Agent Integration

  • MCP server mounted at /mcp using FastMCP streamable HTTP transport.

  • backend/agent_integration/client.py provides AgentDiscovery for listing/invoking tools and an OpenAIAgentBridge to register the server with OpenAI Agents.

Example usage:

from backend.agent_integration.client import AgentDiscovery import asyncio async def main(): discovery = AgentDiscovery("http://localhost:8000", auth_token="change-me") print(await discovery.list_tools()) asyncio.run(main())

Security Highlights

  • Bearer token auth on all mutating endpoints

  • SlowAPI rate limiting (default 10 req/s per IP)

  • Request size checks and security headers (CSP, X-Frame-Options, etc.)

  • Non-root Docker images with capabilities dropped

Detailed guidance in docs/SECURITY.md.

Configuration

See .env.example for required variables:

NEO4J_URI=bolt://neo4j:7687 NEO4J_USER=neo4j NEO4J_PASSWORD=password123 NEO4J_DATABASE=neo4j ALLOWED_ORIGINS=http://localhost:3000 AUTH_TOKEN=change-me RATE_LIMIT_RPS=10

Documentation

Release Packaging

Create an archive for distribution:

zip -r Ultimate_MCP-release.zip \ backend frontend deployment docs scripts \ pyproject.toml README.md .env.example

License

MIT License © 2025 Ultimate MCP maintainers.

Ultimate_MCP

This server cannot be installed

-
security - not tested
-
license - not tested
-
quality - not tested

How are these scores calculated?

hybrid server

The server is able to function both locally and remotely, depending on the configuration or use case.

Turns any LLM into a coding co-pilot with production-ready MCP server providing lint, test, execution, generation, and graph tools. Features Neo4j persistence, OpenAI Agent integration, REST API, and React frontend for comprehensive code development assistance.

  1. Features
    1. Repository Layout
      1. Quickstart
        1. 1. Dependencies
        2. 2. Bootstrap Environment
        3. 3. Run Locally (Developer Mode)
        4. 4. Run with Docker Compose
      2. Testing
        1. MCP & Agent Integration
          1. Security Highlights
            1. Configuration
              1. Documentation
                1. Release Packaging
                  1. License
                    1. Ultimate_MCP

                      New MCP Servers

                      MCP directory API

                      We provide all the information about MCP servers via our MCP API.

                      curl -X GET 'https://glama.ai/api/mcp/v1/servers/Senpai-Sama7/Ultimate_MCP'

                      If you have feedback or need assistance with the MCP directory API, please join our Discord server