DEV Community: Jansen003

## How to Build a Python MCP Server for Claude in 30 Minutes

Jansen003 — Thu, 28 May 2026 15:27:39 +0000

What is MCP?

MCP (Model Context Protocol) is Anthropic's protocol for connecting AI models to external tools. Think of it as USB-C for AI — one standard plug that works with everything.

With MCP, Claude can:

Read and write files on your computer
Query databases
Browse the web
Interact with APIs
Run shell commands

The ecosystem is growing fast. The official MCP servers repo has 86k stars. But there are gaps — especially in Python.

The Gap

Most MCP servers are written in JavaScript or Go. Python developers have very few options for database access, file operations, and other common tasks.

I wanted Python MCP servers. So I built mcp-database — a multi-database MCP server supporting SQLite, PostgreSQL, and MySQL.

mcp-database

pip install mcp-database
claude mcp add mcp-database -e MCP_DATABASE_URL=sqlite:///your.db -- mcp-database

Now you can ask Claude things like "What tables are in my database?" or "Query the top 10 orders by amount."

8 tools: list_tables, get_table_info, get_schema, query, execute, sample_rows, search_tables, list_databases.

Key design decisions:

Read-only by default — safe for production databases
Uses official mcp SDK (FastMCP) — not reinventing the wheel
Multi-database support — one server for SQLite, PostgreSQL, MySQL

How to Build an MCP Server in Python

The MCP Python SDK makes it surprisingly simple. Here is the minimal working server:

from mcp.server.fastmcp import FastMCP

mcp = FastMCP("my-server")

@mcp.tool()
def hello(name: str) -> str:
    # Docstring becomes the tool description
    return f"Hello, {name}!"

if __name__ == "__main__":
    mcp.run()

That is it. The @mcp.tool() decorator turns any Python function into an MCP tool. Type hints become the input schema automatically.

For database servers, the interesting part is the lifespan pattern — managing connections on startup/shutdown:

from collections.abc import AsyncIterator
from contextlib import asynccontextmanager
from dataclasses import dataclass
from mcp.server.fastmcp import FastMCP, Context

@dataclass
class AppContext:
    db: Database

@asynccontextmanager
async def app_lifespan(server: FastMCP) -> AsyncIterator[AppContext]:
    db = await Database.connect()
    try:
        yield AppContext(db=db)
    finally:
        await db.disconnect()

mcp = FastMCP("DB Server", lifespan=app_lifespan)

@mcp.tool()
def query(sql: str, ctx: Context) -> str:
    db = ctx.request_context.lifespan_context.db
    return db.execute(sql)

What I Learned

The official SDK is good. FastMCP handles all the protocol details. You just write Python functions.
Security matters. A database MCP server that allows arbitrary writes is dangerous. Read-only by default, explicit opt-in for writes.
Type hints are your API. The SDK converts Python type hints to JSON Schema automatically. Good types = good tool descriptions.
The ecosystem needs Python servers. Every time I searched for a Python MCP server, I found nothing. The demand is there, the supply is not.

I Let 10 AI Agents Review My Code — Here's What They Caught That Humans Missed

Jansen003 — Thu, 28 May 2026 15:19:28 +0000

The Problem with "LGTM"

We've all been there. You open a PR, your colleague glances at it for 30 seconds, types "LGTM", and merges. No one actually reviews the code. Security vulnerabilities slip through. Performance bugs hide in plain sight.

What if you could deploy 10 specialized AI agents — each an expert in a different domain — to review every PR in parallel?

Meet RevHive

RevHive is an open-source multi-agent code review system. It deploys 10 AI agents simultaneously:

Agent	What It Checks
SecurityAgent	SQL injection, XSS, hardcoded secrets, weak crypto
PerformanceAgent	N+1 queries, memory leaks, algorithmic complexity
LogicAgent	Edge cases, error handling, race conditions
StyleAgent	Naming, formatting, documentation
RepoAgent	Design patterns, SOLID principles, module structure
RefactorAgent	Code transformation, incremental migration
FixAgent	Generates corrected code with root cause analysis
TestAgent	Unit tests, edge case tests, security regression tests
DocAgent	API docs, architecture docs, usage examples
Coordinator	Deduplicates, resolves conflicts, calculates risk score

Try It in 30 Seconds (No API Key Needed)

pip install revhive-ai
revhive demo

The demo runs the complete pipeline with mock responses — you'll see exactly what a real review looks like, including risk scores, severity breakdowns, and actionable findings.

What a Review Looks Like

Every review produces a risk score (0-100) and categorized findings:

Risk Score: 72/100 HIGH
CRITICAL x1   HIGH x3   MEDIUM x8   LOW x11

-- Critical/High Findings --
[CRITICAL] Hardcoded AWS Secret Key
  SecurityAgent - Line 42
  AWS access key found in source code. Move to environment variables.

[HIGH] SQL Injection via String Concatenation
  SecurityAgent - Line 87
  User input directly interpolated into SQL query.

[HIGH] Missing Error Handling in Payment Flow
  LogicAgent - Line 156
  Payment processing has no try/catch — failures are silently swallowed.

[HIGH] N+1 Query in User Dashboard
  PerformanceAgent - Line 203
  Fetching orders inside a user loop — use JOIN or batch query instead.

The Key Insight

The power isn't in any single agent — it's in parallelism and specialization. A human reviewer might catch security issues OR performance issues. RevHive catches both, plus logic bugs, missing tests, and documentation gaps — all in under 30 seconds.

Auto-Review Every PR

Install the GitHub App and every PR gets reviewed automatically. Or use GitHub Actions:

- name: Run RevHive Review
  env:
    LLM_API_KEY: ${{ secrets.LLM_API_KEY }}
    LLM_MODEL: deepseek-chat  # ~$0.05 per review
  run: revhive review --diff HEAD~1 --format markdown

Supported LLMs

Provider	Cost/Review
DeepSeek	~$0.05
MiMo (Xiaomi)	~$0.05-0.15
Qwen (Alibaba)	~$0.05-0.10
GPT-4o	~$0.10-0.30
Claude Sonnet	~$0.15-0.40

DeepSeek is the cheapest — less than 5 cents per PR review.

I Built a Python MCP Server for Databases — So Claude Can Query My DB Directly

Jansen003 — Thu, 28 May 2026 15:18:25 +0000

I got tired of switching between Claude Code and my database client every time I needed to check some data. So I built mcp-database — a Python MCP server that lets Claude query SQLite, PostgreSQL, and MySQL databases directly.

The Problem

You are in Claude Code, writing a feature. You need to check what columns the orders table has. What do you do?

Open a new terminal
Connect to the database
Run DESCRIBE orders
Copy the result
Go back to Claude
Paste it

Six steps for a simple question. Every time.

The Solution

With mcp-database, you just ask Claude:

"What columns does the orders table have?"

Claude calls the get_table_info tool and answers directly. No context switching.

Quick Start

pip install mcp-database
claude mcp add mcp-database -e MCP_DATABASE_URL=sqlite:///your.db -- mcp-database

That is it. Now you can ask Claude things like:

"What tables are in my database?"
"Show me the schema for the users table"
"Query the top 10 orders by amount"
"Find all columns related to email"
"Sample some rows from the products table"

8 Tools

Tool	What It Does
`list_databases`	List all configured database connections
`list_tables`	List all tables
`get_table_info`	Table details (columns, types, row count)
`get_schema`	Full CREATE TABLE statements
`query`	Execute read-only SQL
`execute`	Write operations (opt-in only)
`sample_rows`	See what the data looks like
`search_tables`	Search tables/columns by keyword

Multi-Database Support

# SQLite (built-in)
MCP_DATABASE_URL=sqlite:///path/to/db.sqlite

# PostgreSQL
pip install "mcp-database[postgres]"
MCP_DATABASE_URL=postgres://user:pass@localhost:5432/mydb

# MySQL
pip install "mcp-database[mysql]"
MCP_DATABASE_URL=mysql://user:pass@localhost:3306/mydb

Security First

Read-only by default — your data is safe
Write opt-in — must explicitly set MCP_DATABASE_READ_ONLY=false
Statement detection — write tool rejects SELECT statements
Row limits — max 100 rows by default, configurable

Why Python?

Largest developer community — lower contribution barrier
Uses the official mcp SDK (FastMCP) — not reinventing the wheel
Minimal dependencies — fast install

Claude Desktop Support

Works with Claude Desktop too:

{
  "mcpServers": {
    "database": {
      "command": "mcp-database",
      "env": {
        "MCP_DATABASE_URL": "sqlite:///your.db"
      }
    }
  }
}

I Let 10 AI Agents Review My Code — Here is What They Caught That Humans Missed

Jansen003 — Fri, 15 May 2026 05:11:00 +0000

I Built a 10-Agent AI Code Review System with MiMo — Here's What I Learned

10 specialized AI agents review your code in parallel, 30 seconds to produce a risk report with inline comments on GitHub PRs. Here's the architecture and lessons
learned.

THE PROBLEM

Manual code review is slow. A typical PR takes 1-2 hours to review properly. Reviewers miss things when they're tired. "LGTM" becomes a rubber stamp.

I wanted to build something different: 10 domain experts reviewing simultaneously, each focused on their specialty, with a coordinator synthesizing the results.

THE ARCHITECTURE

The system uses LangGraph to orchestrate 9 parallel review agents, with a CoordinatorAgent that:

Semantic Deduplication (Jaccard similarity)
LLM Conflict Resolution
Risk Score Calculation (0-100)

Key Design Decisions:

Parallel, not sequential — LangGraph schedules all 9 agents simultaneously
Semantic deduplication — Different agents may report the same issue; Coordinator uses Jaccard similarity to merge
Conflict resolution — When SecurityAgent says CRITICAL and StyleAgent says LOW, Coordinator uses LLM to determine the correct severity
Risk scoring — Weighted sum (CRITICAL=25, HIGH=15, MEDIUM=5, LOW=1), capped at 100

THE 10 AGENTS

SecurityAgent — SQL injection, XSS, secrets, weak crypto, auth flaws
LogicAgent — Edge cases, error handling, race conditions, type safety
PerformanceAgent — N+1 queries, memory leaks, algorithmic complexity
StyleAgent — Naming conventions, formatting, documentation
TestAgent — Unit tests, edge case tests, security regression tests
DocAgent — API docs, architecture docs, usage examples
FixAgent — Generates complete corrected code with root cause analysis
RefactorAgent — Design patterns, code transformation, incremental migration
RepoAgent — Architecture review, cross-file dependencies, tech debt
CoordinatorAgent — Deduplication, conflict resolution, risk scoring, report generation

SUPPORTED LLM BACKENDS

RevHive supports 7 LLM backends:

MiMo (Xiaomi) — mimo-v2.5-pro — Default, optimized for token economics
DeepSeek — deepseek-chat — Best cost-performance ratio
Qwen (Alibaba) — qwen-plus — Alibaba Cloud
GLM (Zhipu) — glm-4 — First Chinese LLM support
Kimi (Moonshot) — kimi — Long context
OpenAI — gpt-4o — International standard
Anthropic — claude-sonnet-4 — Best code capability

Usage:
export LLM_API_KEY="sk-xxx" # Any of the 7 backends
revhive review ./my-project

REAL-WORLD USAGE

CLI (30 seconds to start):
# Install
pip install revhive-ai

# Demo mode (no API key needed)
revhive demo

# Real review
export LLM_API_KEY="sk-xxx"
revhive review --file src/main.py

# Review git diff
revhive review --diff HEAD~1

GitHub App (Automatic PR Reviews):
Install the GitHub App → every PR gets reviewed automatically.

Key features:

PR Inline Comments — 8 inline comments pinpointing exact lines
Quality Gate — commit status pass/fail for branch protection
Risk Score — 0-100 score for instant merge decision
Free Tier — 50 reviews/month free

Docker:
docker build -t revhive .
docker run --rm -e LLM_API_KEY=your-api-key -v $(pwd):/code revhive review --file /code/src/main.py

LESSONS LEARNED

Parallel Agents Beat Sequential
Running 9 agents in parallel (via LangGraph) is not just faster — it produces better results. Each agent can focus deeply on its domain without context pollution.
Semantic Deduplication is Critical
Different agents often report the same issue from different angles. Jaccard similarity on keywords is simple but effective for merging duplicates.
Conflict Resolution Needs LLM
When agents disagree on severity, simple rules don't work. Using an LLM to resolve conflicts produces more nuanced results than "take the highest severity."
Chinese LLM Market is Underserved
Most code review tools only support OpenAI/Anthropic. Chinese developers need tools that work with domestic LLMs for cost, latency, and compliance reasons.
Demo Mode is Essential
A demo mode that works without API keys dramatically lowers the barrier to trial. Users can evaluate the tool's output format and quality before committing.

PROJECT STATUS

Version: 0.3.8
License: BSL 1.1 (converts to Apache 2.0 in 2030)
Tests: 81 unit tests
PyPI: pip install revhive-ai
GitHub: https://github.com/Jansen003/RevHive
GitHub App: https://github.com/apps/revhive-bot

TRY IT NOW

# 1. Install
pip install revhive-ai

# 2. Demo (no API key)
revhive demo

# 3. Real review
export LLM_API_KEY="sk-xxx"
revhive review --file src/main.py

# 4. GitHub App (auto PR review)
# https://github.com/apps/revhive-bot

If you find this interesting, give a star ⭐ — it's the biggest encouragement for an indie developer.

Questions, suggestions, or want to discuss multi-agent architecture? Comments below.

Tags: #ai #codereview #multiagent #langgraph #opensource #llm #github #python

DEV Community: Jansen003

## How to Build a Python MCP Server for Claude in 30 Minutes

What is MCP?

The Gap

mcp-database

How to Build an MCP Server in Python

What I Learned

Links

I Let 10 AI Agents Review My Code — Here's What They Caught That Humans Missed

The Problem with "LGTM"

Meet RevHive

Try It in 30 Seconds (No API Key Needed)

What a Review Looks Like

The Key Insight

Auto-Review Every PR

Supported LLMs

Links

I Built a Python MCP Server for Databases — So Claude Can Query My DB Directly

The Problem

The Solution

Quick Start

8 Tools

Multi-Database Support

Security First

Why Python?

Claude Desktop Support

Links

I Let 10 AI Agents Review My Code — Here is What They Caught That Humans Missed