MCP服务器框架

Structural Patterns          Behavioral Patterns         Enterprise Patterns
-------------------          -------------------         -------------------
- Adapter                    - Command                   - API Gateway
- Facade                     - Strategy                  - Service Mesh
- Proxy                      - Observer                  - Circuit Breaker
- Decorator                  - Chain of Responsibility  - Bulkhead

templates/
  python/
    basic/           # Single-purpose MCP server
    enterprise/      # Auth, logging, monitoring
    microservices/   # Distributed MCP architecture
  typescript/
    basic/
    enterprise/
    microservices/
  go/
    basic/
    enterprise/
  rust/
    basic/
    enterprise/

# Install globally
npm install -g mcpforge

# Create a new MCP server
mcpforge new my-server --lang python --pattern adapter

# Add a tool to existing server
mcpforge add tool search --server my-server

# Generate architecture diagram
mcpforge diagram my-server --output svg

# Validate server structure
mcpforge validate my-server

npm install -g mcpforge

mcpforge new my-first-mcp --lang python --pattern basic
cd my-first-mcp

# Python
pip install -e .
python -m my_first_mcp

# TypeScript
npm install
npm run dev

# Python Example
from mcpforge import MCPServer, tool, AdapterPattern

class GitHubAdapter(AdapterPattern):
    """Adapts GitHub API to MCP tools"""

    def __init__(self, token: str):
        self.client = GitHub(token)

    @tool(name="list_repos")
    async def list_repositories(self, org: str) -> list[dict]:
        """List repositories for an organization"""
        return await self.client.repos.list(org=org)

server = MCPServer("github-mcp")
server.register_adapter(GitHubAdapter(token=os.getenv("GITHUB_TOKEN")))

// TypeScript Example
import { MCPServer, tool, AdapterPattern } from 'mcpforge';

class GitHubAdapter extends AdapterPattern {
  private client: Octokit;

  constructor(token: string) {
    super();
    this.client = new Octokit({ auth: token });
  }

  @tool({ name: 'list_repos' })
  async listRepositories(org: string): Promise<Repository[]> {
    const { data } = await this.client.repos.listForOrg({ org });
    return data;
  }
}

                    +------------------+
                    |   MCP Gateway    |
                    |  (Auth, Routing) |
                    +--------+---------+
                             |
         +-------------------+-------------------+
         |                   |                   |
+--------v-------+  +--------v-------+  +--------v-------+
|  GitHub MCP    |  |  Database MCP  |  |  Storage MCP   |
|    Server      |  |    Server      |  |    Server      |
+----------------+  +----------------+  +----------------+

# Gateway Implementation
from mcpforge import Gateway, route, authenticate

gateway = Gateway("mcp-gateway")

@gateway.route("/github/*")
@authenticate(oauth2=True)
async def github_route(request):
    return await gateway.proxy("github-mcp", request)

@gateway.route("/database/*")
@authenticate(api_key=True)
async def database_route(request):
    return await gateway.proxy("database-mcp", request)

mcpforge <command> [options]

Commands:
  new <name>              Create a new MCP server project
  add <type> <name>       Add tool, resource, or prompt to existing project
  diagram <project>       Generate architecture diagram
  validate <project>      Validate project structure and code
  upgrade <project>       Upgrade to latest MCPForge patterns
  docs                    Open documentation in browser

Options:
  --lang, -l              Language: python, typescript, go, rust
  --pattern, -p           Pattern: basic, enterprise, microservices
  --transport, -t         Transport: stdio, sse, http
  --output, -o            Output format for diagrams: svg, png, mermaid
  --help, -h              Show help
  --version, -v           Show version

from mcpforge.security import OAuth2Provider, APIKeyAuth

# OAuth 2.1 (recommended for HTTP transport)
server.use_auth(OAuth2Provider(
    issuer="https://auth.example.com",
    audience="mcp-server"
))

# API Key (for internal services)
server.use_auth(APIKeyAuth(
    header="X-API-Key",
    validator=validate_key
))

from mcpforge.security import RateLimiter

server.use_middleware(RateLimiter(
    requests_per_minute=60,
    burst=10
))

from mcpforge.validation import Schema, validate

@tool(name="query_database")
@validate(Schema({
    "query": str,
    "limit": int & Range(1, 100)
}))
async def query_database(query: str, limit: int = 10):
    # Input is validated before execution
    pass

mcpforge new github-mcp --lang python --pattern adapter
cd github-mcp

# src/github_mcp/server.py
from mcpforge import MCPServer, tool
from github import Github

server = MCPServer("github-mcp")

@server.tool()
async def search_code(query: str, repo: str) -> list[dict]:
    """Search code in a GitHub repository"""
    g = Github(os.getenv("GITHUB_TOKEN"))
    results = g.search_code(f"{query} repo:{repo}")
    return [{"path": r.path, "url": r.html_url} for r in results[:10]]

@server.tool()
async def create_issue(repo: str, title: str, body: str) -> dict:
    """Create a new issue in a repository"""
    g = Github(os.getenv("GITHUB_TOKEN"))
    repo = g.get_repo(repo)
    issue = repo.create_issue(title=title, body=body)
    return {"number": issue.number, "url": issue.html_url}

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

mcpforge new database-mcp --lang typescript --pattern enterprise
cd database-mcp

// src/server.ts
import { MCPServer, tool } from 'mcpforge';
import { Pool } from 'pg';

const server = new MCPServer('database-mcp');
const pool = new Pool({ connectionString: process.env.DATABASE_URL });

server.tool({
  name: 'query',
  description: 'Execute a read-only SQL query',
  schema: {
    sql: { type: 'string', description: 'SQL query to execute' },
    params: { type: 'array', optional: true }
  }
}, async ({ sql, params }) => {
  // Only allow SELECT statements
  if (!sql.trim().toLowerCase().startsWith('select')) {
    throw new Error('Only SELECT queries are allowed');
  }
  const result = await pool.query(sql, params);
  return result.rows;
});

server.run();

mcpforge diagram my-server --output svg

+------------------------------------------------------------------+
|                         MCP Client                                |
|                    (Claude, ChatGPT, etc.)                        |
+----------------------------------+-------------------------------+
                                   |
                                   v
+------------------------------------------------------------------+
|                        MCP Gateway                                |
|          [Auth] [Rate Limit] [Logging] [Routing]                  |
+--------+-------------------+-------------------+-----------------+
         |                   |                   |
         v                   v                   v
+----------------+  +----------------+  +----------------+
|  GitHub MCP    |  |  Database MCP  |  |  Storage MCP   |
|                |  |                |  |                |
| Tools:         |  | Tools:         |  | Tools:         |
| - search_code  |  | - query        |  | - upload       |
| - create_issue |  | - list_tables  |  | - download     |
| - list_repos   |  | - describe     |  | - list_files   |
+----------------+  +----------------+  +----------------+

git clone https://github.com/Richardmsbr/mcpforge.git
cd mcpforge
npm install
npm run build
npm link

npm test                    # Unit tests
npm run test:integration    # Integration tests
npm run test:e2e           # End-to-end tests