CGM MCP Server

Um servidor para CodeFuse-CGM, um modelo de linguagem grande integrado a grafos projetado para tarefas de engenharia de software em nível de repositório.

GitHub

Experimente este MCPPatrocinado

Documentação

Servidor MCP CGM

Uma implementação de servidor Model Context Protocol (MCP) do CodeFuse-CGM (Code Graph Model), fornecendo capacidades de modelo de linguagem de grande porte integradas a grafos para tarefas de engenharia de software em nível de repositório.

🚀 Recursos

🎯 Dois Modos de Implantação

1. Pipeline CGM Completo (com integração LLM)

Análise de Código em Nível de Repositório: Analise bases de código inteiras usando representações baseadas em grafos
Resolução de Problemas: Gere automaticamente patches de código para corrigir bugs e implementar funcionalidades
Pipeline de Quatro Estágios: Arquitetura Rewriter → Retriever → Reranker → Reader
Suporte Multi-LLM: Funciona com OpenAI, Anthropic, Ollama, Ollama Cloud, LM Studio

2. Ferramentas Independentes de Modelo (análise pura, sem necessidade de LLM) ⭐

Análise de Código Pura: Extraia estrutura de código sem dependências de LLM
Integração Universal: Funciona com QUALQUER modelo de IA ou IDE
Sem Chaves de API Necessárias: Zero dependências externas
Alto Desempenho: Resultados de análise em cache para velocidade

⚡ Desempenho e Aceleração de GPU

Suporte Multi-Plataforma de GPU 🎯

Apple Silicon (M1/M2/M3): Aceleração MPS nativa (42x de aceleração de cache!)
GPU NVIDIA: Suporte completo a CUDA com integração cuPy
GPU AMD: Suporte a ROCm (Linux) e DirectML (Windows)
Fallback para CPU: Fallback automático garante compatibilidade universal

☁️ Suporte a Ollama Cloud

Provedor Ollama Cloud 🌐

Modelos Ollama Baseados em Nuvem: Execute modelos compatíveis com Ollama na nuvem
Compatibilidade de API: Compatível com o formato de API do Ollama
Configuração Fácil: Funciona com nomes de modelos Ollama padrão
Acesso Seguro: Suporta autenticação por chave de API

Sistema Avançado de Cache 🗄️

Cache em Múltiplos Níveis: Cache TTL (1h) + cache LRU (500 entradas) + cache AST
Chaves de Cache Inteligentes: Chaves de cache baseadas em MD5 para buscas eficientes
Gerenciamento de Memória: Monitoramento em tempo real com limpeza automática
Estatísticas de Desempenho: Índices detalhados de acertos/erros e métricas de tempo

Processamento Concorrente 🔄

I/O de Arquivos Assíncrono: Operações de arquivo não bloqueantes com aiofiles
Processamento em Lote: Análise concorrente de múltiplos arquivos
Acelerado por GPU: Correspondência de entidades e processamento de texto na GPU
Agendamento Inteligente: Limites de concorrência controlados por semáforo

🔧 Recursos Comuns

Integração MCP: Compatível com Claude Desktop, VS Code, Cursor e outros clientes MCP
Contexto Baseado em Grafos: Aproveita a estrutura e os relacionamentos do código para melhor compreensão
Múltiplos Formatos de Saída: JSON estruturado, Markdown e formatos de Prompt
Monitoramento em Tempo Real: Uso de GPU, consumo de memória e métricas de desempenho

🛠 Instalação

Pré-requisitos

Python 3.8+
pip ou conda

Instalar a partir do Código Fonte

# Clone the repository
git clone https://github.com/your-org/cgm-mcp.git
cd cgm-mcp

# Install dependencies
pip install -r requirements.txt

# Or install in development mode
pip install -e .

Configuração de Aceleração de GPU (Opcional)

🍎 Apple Silicon (M1/M2/M3) - Automático

# No additional setup needed!
# MPS (Metal Performance Shaders) is automatically detected and enabled
pip install torch torchvision torchaudio  # Usually already installed

🟢 GPU NVIDIA

# Install CUDA-enabled PyTorch
pip install torch --index-url https://download.pytorch.org/whl/cu118

# Optional: Enhanced GPU features
pip install cupy-cuda11x  # For CUDA 11.x
# or
pip install cupy-cuda12x  # For CUDA 12.x

🔴 GPU AMD

# Linux (ROCm)
pip install torch --index-url https://download.pytorch.org/whl/rocm5.6

# Windows (DirectML)
pip install torch-directml

Instalar a partir do PyPI (Em Breve)

pip install cgm-mcp

⚡ Início Rápido

1. Configurar o Ambiente

# Run setup script
./scripts/setup.sh

# Copy example environment file
cp .env.example .env

2. Escolha seu Provedor de Modelo

Opção A: Usar Modelos em Nuvem (OpenAI/Anthropic)

# Edit .env with your API keys
export CGM_LLM_PROVIDER=openai
export CGM_LLM_API_KEY=your-openai-api-key
export CGM_LLM_MODEL=gpt-4

Opção B: Usar Modelos Locais (Recomendado)

# Install and start Ollama
curl -fsSL https://ollama.ai/install.sh | sh
ollama serve

# Download recommended model
ollama pull deepseek-coder:6.7b

# Start with local model
./scripts/start_local.sh --provider ollama --model deepseek-coder:6.7b

Opção C: Usar LM Studio

# Download and start LM Studio
# Load deepseek-coder-6.7b-instruct model
# Start local server

# Start CGM with LM Studio
./scripts/start_local.sh --provider lmstudio

3. Iniciar o Servidor

# Start MCP server (cloud models)
python main.py

# Start with local models
./scripts/start_local.sh

# Or with custom config
python main.py --config config.local.json --log-level DEBUG

4. Testar com Exemplo

# Run example usage
python examples/example_usage.py

# Check GPU acceleration status
python check_gpu_dependencies.py

⚡ Desempenho e Configuração de GPU

🔍 Verifique o Status da sua GPU

# Run the GPU dependency checker
python check_gpu_dependencies.py

Saída esperada para Apple Silicon:

🎉 OPTIMAL: Apple Silicon GPU acceleration is active!
   • MPS backend enabled
   • No additional dependencies needed
   • CuPy warnings can be ignored

📊 Benchmarks de Desempenho

Plataforma	Correspondência de Entidades	Processamento de Texto	Taxa de Acerto de Cache
Apple Silicon (MPS)	42x de aceleração (em cache)	~0,001s (200 arquivos)	95%+
NVIDIA CUDA	5-10x de aceleração	3-5x de aceleração	90%+
AMD ROCm	3-8x de aceleração	2-4x de aceleração	90%+
Fallback para CPU	Linha de base	Linha de base	85%+

🛠️ Recursos de Desempenho

Sistema de Cache Inteligente

Cache TTL: Expiração de 1 hora para resultados de análise
Cache LRU: 500 arquivos mais recentes mantidos em memória
Cache AST: 200 árvores sintáticas analisadas em cache
Cache de Embeddings: Vetores de similaridade acelerados por GPU

Gerenciamento de Memória

Monitoramento em Tempo Real: Acompanhe o uso de memória da GPU e do sistema
Limpeza Automática: Limpe caches quando o uso de memória > 80%
Memória Unificada: Memória compartilhada CPU/GPU do Apple Silicon
Pools de Memória: Alocação eficiente de memória da GPU

Processamento Concorrente

I/O de Arquivos Assíncrono: Operações de arquivo não bloqueantes
Processamento em Lote: Processe múltiplos arquivos simultaneamente
Controle por Semáforo: Limite operações concorrentes (padrão: 10)
Fila de GPU: Agendamento inteligente de tarefas de GPU

🔧 Ajuste de Desempenho

Variáveis de Ambiente

# GPU Configuration
export CGM_USE_GPU=true                    # Enable GPU acceleration
export CGM_GPU_BATCH_SIZE=1024            # Batch size for GPU operations
export CGM_SIMILARITY_THRESHOLD=0.1       # Entity similarity threshold
export CGM_CACHE_EMBEDDINGS=true          # Cache embedding vectors

# Memory Management
export CGM_MAX_CACHE_SIZE=500             # Maximum cached files
export CGM_MEMORY_CLEANUP_THRESHOLD=80    # Memory cleanup trigger (%)
export CGM_GPU_MEMORY_FRACTION=0.8        # GPU memory usage limit

Arquivo de Configuração

{
  "gpu": {
    "use_gpu": true,
    "batch_size": 1024,
    "max_sequence_length": 512,
    "similarity_threshold": 0.1,
    "cache_embeddings": true,
    "gpu_memory_fraction": 0.8
  },
  "performance": {
    "max_concurrent_files": 10,
    "cache_ttl_seconds": 3600,
    "max_file_cache_size": 500,
    "memory_cleanup_threshold": 80
  }
}

⚙️ Configuração

Variáveis de Ambiente

Variável	Descrição	Padrão
`CGM_LLM_PROVIDER`	Provedor de LLM (openai, anthropic, ollama, ollama_cloud, lmstudio, mock)	`openai`
`CGM_LLM_API_KEY`	Chave de API para o provedor de LLM (não necessária para modelos locais)	Necessária para nuvem
`CGM_LLM_MODEL`	Nome do modelo	`gpt-4`
`CGM_LLM_API_BASE`	URL base de API personalizada (para modelos locais)	Padrão do provedor
`CGM_LLM_TEMPERATURE`	Temperatura de geração	`0.1`
`CGM_LOG_LEVEL`	Nível de registro de log	`INFO`

Arquivo de Configuração

Crie um arquivo config.json:

Configuração de Modelos em Nuvem

{
  "llm": {
    "provider": "openai",
    "model": "gpt-4",
    "temperature": 0.1,
    "max_tokens": 4000
  }
}

Configuração de Modelos Locais

{
  "llm": {
    "provider": "ollama",
    "model": "deepseek-coder:6.7b",
    "api_base": "http://localhost:11434",
    "temperature": 0.1,
    "max_tokens": 4000
  },
  "graph": {
    "max_nodes": 5000,
    "max_edges": 25000,
    "cache_enabled": true
  },
  "server": {
    "log_level": "INFO",
    "max_concurrent_tasks": 3
  }
}

📖 Uso

Ferramentas MCP

O servidor fornece as seguintes ferramentas MCP:

Ferramentas de Análise

`cgm_analyze_repository`

Analise a estrutura do repositório e extraia entidades de código com aceleração de GPU.

Parâmetros:

repository_path: Caminho para o repositório
query: Consulta de busca para código relevante
analysis_scope: Escopo da análise (full, focused, minimal)
max_files: Número máximo de arquivos a analisar

`cgm_get_file_content`

Obtenha conteúdo detalhado de arquivos e análise com processamento concorrente.

Parâmetros:

repository_path: Caminho para o repositório
file_paths: Lista de caminhos de arquivos a analisar

`cgm_find_related_code`

Encontre entidades de código relacionadas a uma entidade específica usando correspondência de similaridade acelerada por GPU.

Parâmetros:

repository_path: Caminho para o repositório
entity_name: Nome da entidade para encontrar relações
relation_types: Tipos de relações a incluir (opcional)

`cgm_extract_context`

Extraia contexto estruturado para consumo por modelos externos.

Parâmetros:

repository_path: Caminho para o repositório
query: Consulta para extração de contexto
format: Formato de saída (structured, markdown, prompt)

Ferramentas de Desempenho

`clear_gpu_cache`

Limpe caches de GPU para liberar memória.

Parâmetros: Nenhum

Ferramentas Legadas

`cgm_process_issue`

Processe um problema do repositório usando o framework CGM.

Parâmetros:

task_type: Tipo de tarefa (issue_resolution, code_analysis, bug_fixing, feature_implementation)
repository_name: Nome do repositório
issue_description: Descrição do problema
repository_context: Contexto opcional do repositório

Exemplo:

{
  "task_type": "issue_resolution",
  "repository_name": "my-project",
  "issue_description": "Authentication fails with special characters in password",
  "repository_context": {
    "path": "/path/to/repository",
    "language": "Python",
    "framework": "Django"
  }
}

`cgm_get_task_status`

Obtenha o status de uma tarefa em execução.

Parâmetros:

task_id: ID da tarefa a verificar

`cgm_health_check`

Verifique o status de saúde do servidor.

Recursos MCP

Recursos do Sistema

cgm://health: Informações de saúde do servidor
cgm://tasks: Lista de tarefas ativas

Recursos de Desempenho

cgm://cache: Estatísticas de cache e índices de acertos/erros
cgm://performance: Métricas de desempenho do servidor e uso de memória
cgm://gpu: Status de aceleração de GPU e uso de memória

Exemplo de Acesso a Recursos

# Check GPU status
curl "cgm://gpu"

# Monitor cache performance
curl "cgm://cache"

# View performance metrics
curl "cgm://performance"

🏗 Arquitetura

O CGM segue um pipeline de quatro estágios:

graph LR
    A[Issue] --> B[Rewriter]
    B --> C[Retriever]
    C --> D[Reranker]
    D --> E[Reader]
    E --> F[Code Patches]
    
    G[Code Graph] --> C
    G --> D
    G --> E

Componentes

Rewriter: Analisa problemas e extrai entidades e palavras-chave relevantes
Retriever: Localiza subgrafos de código relevantes com base nas informações extraídas
Reranker: Classifica arquivos por relevância para focar a análise
Reader: Gera patches de código específicos para resolver problemas

Construtor de Grafos

Constrói grafos de código em nível de repositório analisando:

Estrutura de arquivos e dependências
Definições de classes e funções
Relacionamentos de importação
Semântica do código e documentação

📚 Referência da API

Modelos Principais

`CGMRequest`

class CGMRequest(BaseModel):
    task_type: TaskType
    repository_name: str
    issue_description: str
    repository_context: Optional[Dict[str, Any]] = None

`CGMResponse`

class CGMResponse(BaseModel):
    task_id: str
    status: str
    rewriter_result: Optional[RewriterResponse]
    retriever_result: Optional[RetrieverResponse]
    reranker_result: Optional[RerankerResponse]
    reader_result: Optional[ReaderResponse]
    processing_time: float

`CodePatch`

class CodePatch(BaseModel):
    file_path: str
    original_code: str
    modified_code: str
    line_start: int
    line_end: int
    explanation: str

💡 Exemplos

Resolução Básica de Problemas

import asyncio
from cgm_mcp.server import CGMServer
from cgm_mcp.models import CGMRequest, TaskType

async def resolve_issue():
    server = CGMServer(config)
    
    request = CGMRequest(
        task_type=TaskType.ISSUE_RESOLUTION,
        repository_name="my-app",
        issue_description="Login fails with special characters",
        repository_context={"path": "./my-app"}
    )
    
    response = await server._process_issue(request.dict())
    
    for patch in response.reader_result.patches:
        print(f"File: {patch.file_path}")
        print(f"Changes: {patch.explanation}")

Integração com Claude Desktop

Adicione à sua configuração MCP do Claude Desktop:

{
  "mcpServers": {
    "cgm": {
      "command": "python",
      "args": ["/path/to/cgm-mcp/main.py"],
      "env": {
        "CGM_LLM_API_KEY": "your-api-key"
      }
    }
  }
}

📊 Monitoramento de Desempenho

Métricas em Tempo Real

Estatísticas de GPU

{
  "memory": {
    "gpu_available": true,
    "platform": "Apple Silicon",
    "backend": "Metal Performance Shaders",
    "gpu_memory_allocated": 0.6
  },
  "performance": {
    "gpu_entity_matches": 15,
    "cache_hit_rate": 94.2
  }
}

Desempenho do Cache

{
  "analysis_cache": {"size": 45, "maxsize": 100},
  "file_cache": {"size": 234, "maxsize": 500},
  "stats": {"hits": 156, "misses": 23, "hit_rate": 87.2}
}

Teste de Desempenho

# Check GPU acceleration status
python check_gpu_dependencies.py

# Run performance tests
python gpu_verification.py
python test_multiplatform_gpu.py

🧪 Testes

# Run tests
pytest tests/

# Run with coverage
pytest tests/ --cov=cgm_mcp

# Run specific test
pytest tests/test_components.py::TestRewriterComponent

# Performance tests
python test_gpu_acceleration.py
python gpu_verification.py

🚀 Resumo dos Recursos de Desempenho

⚡ Aceleração de GPU

Apple Silicon: Suporte MPS nativo com 42x de aceleração de cache
GPU NVIDIA: Suporte completo a CUDA com integração cuPy
GPU AMD: Suporte a ROCm (Linux) e DirectML (Windows)
Detecção Automática: Detecção inteligente de plataforma e fallback

🗄️ Cache Inteligente

Múltiplos Níveis: TTL (1h) + LRU (500 arquivos) + AST (200 árvores)
Inteligente: Chaves de cache baseadas em MD5 com monitoramento de taxa de acertos
Consciente de Memória: Limpeza automática a 80% de uso de memória
Desempenho: Taxas de acerto de cache de 85-95% em produção

🔄 Processamento Concorrente

I/O Assíncrono: Operações de arquivo não bloqueantes com aiofiles
Processamento em Lote: Análise concorrente de múltiplos arquivos
Controle por Semáforo: Limites de concorrência configuráveis (padrão: 10)
Fila de GPU: Agendamento inteligente de tarefas de GPU

📊 Monitoramento em Tempo Real

Estatísticas de GPU: Uso de memória, detecção de plataforma, métricas de desempenho
Análise de Cache: Índices de acertos/erros, monitoramento de tamanho, eventos de limpeza
Métricas do Sistema: Uso de memória, utilização de CPU, tempos de processamento
Recursos MCP: cgm://gpu, cgm://cache, cgm://performance

🤝 Contribuição

Faça um fork do repositório
Crie um branch de funcionalidade (git checkout -b feature/amazing-feature)
Faça commit das suas alterações (git commit -m 'Add amazing feature')
Envie para o branch (git push origin feature/amazing-feature)
Abra um Pull Request

📄 Licença

Este projeto é licenciado sob a Licença MIT - consulte o arquivo LICENSE para detalhes.

🙏 Agradecimentos

CodeFuse-CGM - Implementação original do CGM
PocketFlow - Inspiração do framework
Model Context Protocol - Especificação MCP

📞 Suporte

📧 E-mail: cgm-mcp@example.com
🐛 Problemas: GitHub Issues
💬 Discussões: GitHub Discussions

CGM MCP Server - Trazendo inteligência de código integrada a grafos para o seu fluxo de trabalho de desenvolvimento! 🚀