CGM MCP Server

Un servidor para CodeFuse-CGM, un modelo de lenguaje grande integrado con grafos diseñado para tareas de ingeniería de software a nivel de repositorio.

GitHub

Prueba este MCPPatrocinado

Documentación

CGM MCP Server

Una implementación de servidor Model Context Protocol (MCP) de CodeFuse-CGM (Code Graph Model), que proporciona capacidades de modelos de lenguaje grandes integrados con grafos para tareas de ingeniería de software a nivel de repositorio.

🚀 Características

🎯 Dos Modos de Implementación

1. Pipeline CGM Completo (con integración de LLM)

Análisis de Código a Nivel de Repositorio: Analiza bases de código completas utilizando representaciones basadas en grafos
Resolución de Problemas: Genera automáticamente parches de código para corregir errores e implementar funciones
Pipeline de Cuatro Etapas: Arquitectura Rewriter → Retriever → Reranker → Reader
Soporte Multi-LLM: Funciona con OpenAI, Anthropic, Ollama, Ollama Cloud, LM Studio

2. Herramientas Independientes del Modelo (análisis puro, sin necesidad de LLM) ⭐

Análisis de Código Puro: Extrae la estructura del código sin dependencias de LLM
Integración Universal: Funciona con CUALQUIER modelo de IA o IDE
Sin Claves API Requeridas: Cero dependencias externas
Alto Rendimiento: Resultados de análisis en caché para mayor velocidad

⚡ Rendimiento y Aceleración por GPU

Soporte Multi-Plataforma de GPU 🎯

Apple Silicon (M1/M2/M3): Aceleración MPS nativa (¡42x de velocidad en caché!)
GPU NVIDIA: Soporte CUDA completo con integración cuPy
GPU AMD: Soporte ROCm (Linux) y DirectML (Windows)
Respaldo por CPU: Respaldo automático que garantiza compatibilidad universal

☁️ Soporte de Ollama Cloud

Proveedor Ollama Cloud 🌐

Modelos Ollama Basados en la Nube: Ejecuta modelos compatibles con Ollama en la nube
Compatibilidad de API: Compatible con el formato de API de Ollama
Configuración Sencilla: Funciona con nombres de modelos Ollama estándar
Acceso Seguro: Soporta autenticación mediante clave API

Sistema Avanzado de Caché 🗄️

Caché Multinivel: Caché TTL (1 hora) + caché LRU (500 entradas) + caché AST
Claves de Caché Inteligentes: Claves de caché basadas en MD5 para búsquedas eficientes
Gestión de Memoria: Monitoreo en tiempo real con limpieza automática
Estadísticas de Rendimiento: Ratios detallados de aciertos/fallos y métricas de tiempo

Procesamiento Concurrente 🔄

E/S de Archivos Asíncrona: Operaciones de archivos no bloqueantes con aiofiles
Procesamiento por Lotes: Análisis concurrente de múltiples archivos
Acelerado por GPU: Coincidencia de entidades y procesamiento de texto en GPU
Programación Inteligente: Límites de concurrencia controlados por semáforos

🔧 Características Comunes

Integración MCP: Compatible con Claude Desktop, VS Code, Cursor y otros clientes MCP
Contexto Basado en Grafos: Aprovecha la estructura y las relaciones del código para una mejor comprensión
Múltiples Formatos de Salida: JSON estructurado, Markdown y formatos de Prompt
Monitoreo en Tiempo Real: Uso de GPU, consumo de memoria y métricas de rendimiento

🛠 Instalación

Requisitos Previos

Python 3.8+
pip o conda

Instalar desde el Código Fuente

# 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 .

Configuración de Aceleración por 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 desde PyPI (Próximamente)

pip install cgm-mcp

⚡ Inicio Rápido

1. Configurar el Entorno

# Run setup script
./scripts/setup.sh

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

2. Elegir su Proveedor de Modelo

Opción A: Usar Modelos en la Nube (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

Opción B: Usar Modelos Locales (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

Opción 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 el 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. Probar con un Ejemplo

# Run example usage
python examples/example_usage.py

# Check GPU acceleration status
python check_gpu_dependencies.py

⚡ Rendimiento y Configuración de GPU

🔍 Verificar el Estado de su GPU

# Run the GPU dependency checker
python check_gpu_dependencies.py

Salida esperada para Apple Silicon:

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

📊 Puntos de Referencia de Rendimiento

Plataforma	Coincidencia de Entidades	Procesamiento de Texto	Tasa de Aciertos de Caché
Apple Silicon (MPS)	42x de velocidad (en caché)	~0.001s (200 archivos)	95%+
NVIDIA CUDA	5-10x de velocidad	3-5x de velocidad	90%+
AMD ROCm	3-8x de velocidad	2-4x de velocidad	90%+
Respaldo por CPU	Línea base	Línea base	85%+

🛠️ Características de Rendimiento

Sistema de Caché Inteligente

Caché TTL: Expiración de 1 hora para resultados de análisis
Caché LRU: 500 archivos más recientes mantenidos en memoria
Caché AST: 200 árboles de sintaxis analizados en caché
Caché de Embeddings: Vectores de similitud acelerados por GPU

Gestión de Memoria

Monitoreo en Tiempo Real: Rastrear el uso de memoria de GPU y del sistema
Limpieza Automática: Limpiar cachés cuando el uso de memoria supera el 80%
Memoria Unificada: Memoria compartida CPU/GPU de Apple Silicon
Pools de Memoria: Asignación eficiente de memoria de GPU

Procesamiento Concurrente

E/S de Archivos Asíncrona: Operaciones de archivos no bloqueantes
Procesamiento por Lotes: Procesar múltiples archivos simultáneamente
Control por Semáforos: Limitar operaciones concurrentes (predeterminado: 10)
Colas de GPU: Programación inteligente de tareas de GPU

🔧 Ajuste de Rendimiento

Variables de Entorno

# 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

Archivo de Configuración

{
  "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
  }
}

⚙️ Configuración

Variables de Entorno

Variable	Descripción	Predeterminado
`CGM_LLM_PROVIDER`	Proveedor de LLM (openai, anthropic, ollama, ollama_cloud, lmstudio, mock)	`openai`
`CGM_LLM_API_KEY`	Clave API para el proveedor de LLM (no necesaria para modelos locales)	Requerida para la nube
`CGM_LLM_MODEL`	Nombre del modelo	`gpt-4`
`CGM_LLM_API_BASE`	URL base de API personalizada (para modelos locales)	Predeterminado del proveedor
`CGM_LLM_TEMPERATURE`	Temperatura de generación	`0.1`
`CGM_LOG_LEVEL`	Nivel de registro	`INFO`

Archivo de Configuración

Cree un archivo config.json:

Configuración de Modelos en la Nube

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

Configuración de Modelos Locales

{
  "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

Herramientas MCP

El servidor proporciona las siguientes herramientas MCP:

Herramientas de Análisis

`cgm_analyze_repository`

Analiza la estructura del repositorio y extrae entidades de código con aceleración por GPU.

Parámetros:

repository_path: Ruta al repositorio
query: Consulta de búsqueda para código relevante
analysis_scope: Alcance del análisis (full, focused, minimal)
max_files: Número máximo de archivos a analizar

`cgm_get_file_content`

Obtiene contenido detallado de archivos y análisis con procesamiento concurrente.

Parámetros:

repository_path: Ruta al repositorio
file_paths: Lista de rutas de archivos a analizar

`cgm_find_related_code`

Encuentra entidades de código relacionadas con una entidad específica utilizando coincidencia de similitud acelerada por GPU.

Parámetros:

repository_path: Ruta al repositorio
entity_name: Nombre de la entidad para la cual encontrar relaciones
relation_types: Tipos de relaciones a incluir (opcional)

`cgm_extract_context`

Extrae contexto estructurado para consumo por modelos externos.

Parámetros:

repository_path: Ruta al repositorio
query: Consulta para extracción de contexto
format: Formato de salida (structured, markdown, prompt)

Herramientas de Rendimiento

`clear_gpu_cache`

Limpia las cachés de GPU para liberar memoria.

Parámetros: Ninguno

Herramientas Heredadas

`cgm_process_issue`

Procesa un problema del repositorio utilizando el framework CGM.

Parámetros:

task_type: Tipo de tarea (issue_resolution, code_analysis, bug_fixing, feature_implementation)
repository_name: Nombre del repositorio
issue_description: Descripción del problema
repository_context: Contexto del repositorio (opcional)

Ejemplo:

{
  "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`

Obtiene el estado de una tarea en ejecución.

Parámetros:

task_id: ID de la tarea a verificar

`cgm_health_check`

Verifica el estado de salud del servidor.

Recursos MCP

Recursos del Sistema

cgm://health: Información de salud del servidor
cgm://tasks: Lista de tareas activas

Recursos de Rendimiento

cgm://cache: Estadísticas de caché y ratios de aciertos/fallos
cgm://performance: Métricas de rendimiento del servidor y uso de memoria
cgm://gpu: Estado de aceleración por GPU y uso de memoria

Ejemplo de Acceso a Recursos

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

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

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

🏗 Arquitectura

CGM sigue un pipeline de cuatro etapas:

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: Analiza problemas y extrae entidades y palabras clave relevantes
Retriever: Localiza subgrafos de código relevantes basándose en la información extraída
Reranker: Clasifica archivos por relevancia para enfocar el análisis
Reader: Genera parches de código específicos para resolver problemas

Constructor de Grafos

Construye grafos de código a nivel de repositorio analizando:

Estructura de archivos y dependencias
Definiciones de clases y funciones
Relaciones de importación
Semántica del código y documentación

📚 Referencia de API

Modelos Principales

`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

💡 Ejemplos

Resolución 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}")

Integración con Claude Desktop

Agregue a su configuración MCP de Claude Desktop:

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

📊 Monitoreo de Rendimiento

Métricas en Tiempo Real

Estadí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
  }
}

Rendimiento de Caché

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

Pruebas de Rendimiento

# Check GPU acceleration status
python check_gpu_dependencies.py

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

🧪 Pruebas

# 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

🚀 Resumen de Características de Rendimiento

⚡ Aceleración por GPU

Apple Silicon: Soporte MPS nativo con 42x de velocidad en caché
GPU NVIDIA: Soporte CUDA completo con integración cuPy
GPU AMD: Soporte ROCm (Linux) y DirectML (Windows)
Detección Automática: Detección inteligente de plataforma y respaldo

🗄️ Caché Inteligente

Multinivel: TTL (1 hora) + LRU (500 archivos) + AST (200 árboles)
Inteligente: Claves de caché basadas en MD5 con monitoreo de tasa de aciertos
Consciente de Memoria: Limpieza automática al 80% de uso de memoria
Rendimiento: 85-95% de tasas de aciertos de caché en producción

🔄 Procesamiento Concurrente

E/S Asíncrona: Operaciones de archivos no bloqueantes con aiofiles
Procesamiento por Lotes: Análisis concurrente de múltiples archivos
Control por Semáforos: Límites de concurrencia configurables (predeterminado: 10)
Colas de GPU: Programación inteligente de tareas de GPU

📊 Monitoreo en Tiempo Real

Estadísticas de GPU: Uso de memoria, detección de plataforma, métricas de rendimiento
Analíticas de Caché: Ratios de aciertos/fallos, monitoreo de tamaño, eventos de limpieza
Métricas del Sistema: Uso de memoria, utilización de CPU, tiempos de procesamiento
Recursos MCP: cgm://gpu, cgm://cache, cgm://performance

🤝 Contribuciones

Haga un fork del repositorio
Cree una rama de características (git checkout -b feature/amazing-feature)
Confirme sus cambios (git commit -m 'Add amazing feature')
Haga push a la rama (git push origin feature/amazing-feature)
Abra un Pull Request

📄 Licencia

Este proyecto está licenciado bajo la Licencia MIT - consulte el archivo LICENSE para más detalles.

🙏 Agradecimientos

CodeFuse-CGM - Implementación original de CGM
PocketFlow - Inspiración del framework
Model Context Protocol - Especificación MCP

📞 Soporte

📧 Correo electrónico: cgm-mcp@example.com
🐛 Problemas: GitHub Issues
💬 Discusiones: GitHub Discussions

CGM MCP Server - ¡Llevando inteligencia de código integrada con grafos a su flujo de trabajo de desarrollo! 🚀