Servidor MCP con integración con OpenAI, Git, sistema de archivos y Prometheus

Este repositorio contiene una implementación de servidor de plano de control de modelo (MCP) que admite servicios OpenAI, análisis de repositorios Git, operaciones de sistemas de archivos locales e integración de Prometheus.

Estructura del proyecto

MCP/
├── mcp/               # Core MCP library modules
├── scripts/           # Utility scripts and test tools
├── prometheus/        # Prometheus configuration
├── docker-compose.yml # Docker configuration
├── mcp_server.py      # Main server implementation
├── mcp_run            # Main runner script (shortcut)
└── README.md          # This file

Related MCP server: MCP GitHub Repository Server

Requisitos

• Python 3.8+

• API rápida

• Uvicornio

• Kit de desarrollo de software de OpenAI

• GitPython

• Solicitudes

• Docker y Docker Compose (para las funciones de Prometheus)

Instalación

1. Clonar este repositorio

2. Instalar las dependencias:

pip install -r requirements.txt

Variables de entorno

Establezca las siguientes variables de entorno:

Para Azure OpenAI:

export AZURE_OPENAI_ENDPOINT="your-azure-endpoint"
export AZURE_OPENAI_API_KEY="your-azure-api-key"
export AZURE_OPENAI_API_VERSION="2023-05-15"
export AZURE_DEPLOYMENT_NAME="your-deployment-name"

Para OpenAI estándar:

export OPENAI_API_KEY="your-openai-api-key"
# Optional: Specify which models to use
export OPENAI_CHAT_MODEL="gpt-4o-mini"  # Default if not specified
export OPENAI_COMPLETION_MODEL="gpt-3.5-turbo-instruct"  # Default if not specified

Para Prometeo:

export PROMETHEUS_URL="http://localhost:9090"  # Default if not specified

Ejecución del servidor

Inicie el servidor MCP:

python scripts/start_mcp_server.py

O para más opciones:

python scripts/start_mcp_server.py --host 0.0.0.0 --port 8000 --debug

El servidor estará disponible en http://localhost:8000 .

Herramienta de prueba unificada

Proporcionamos un script de prueba unificado que le brinda una interfaz fácil de usar para todas las funciones de prueba:

./mcp_run

Este script interactivo proporciona:

• Pruebas del sistema de archivos

• Pruebas de integración de Git

• Herramientas de análisis de memoria

• Pruebas de Prometeo y estrés de la memoria

• Gestión de servidores MCP

• Configuración del entorno

Pruebas individuales

También puedes ejecutar pruebas individuales directamente:

Pruebe la integración de OpenAI:

python scripts/test_mcp_client.py

Pruebe la integración de Git (proporcione una URL del repositorio de Git):

python scripts/test_git_integration.py https://github.com/username/repository

Pruebe la funcionalidad de diferencias de Git (analice la compatibilidad de requisitos):

python scripts/test_git_diff.py https://github.com/username/repository [commit-sha]

Pruebe la funcionalidad del sistema de archivos:

python scripts/test_filesystem.py

Pruebe la integración de langflow con MCP:

python scripts/test_langflow_integration.py [OPTIONAL_REPO_URL]

Pruebe la integración de Prometheus:

python scripts/test_prometheus.py [prometheus_url]

Análisis avanzado de Git

Para un análisis más avanzado del repositorio Git con recomendaciones de IA:

python scripts/langflow_git_analyzer.py https://github.com/username/repository

También puedes buscar patrones específicos en el repositorio:

python scripts/langflow_git_analyzer.py https://github.com/username/repository --search "def main"

O analice la última diferencia de confirmación con información de IA:

python scripts/langflow_git_analyzer.py https://github.com/username/repository --diff

Herramientas de análisis de memoria

MCP incluye varias herramientas para la monitorización y análisis de la memoria:

# Basic memory diagnostics with AI analysis
python scripts/ai_memory_diagnostics.py

# Interactive memory dashboard
python scripts/mcp_memory_dashboard.py

# Memory alerting system
python scripts/mcp_memory_alerting.py

También puedes simular la presión de la memoria para realizar pruebas:

python scripts/simulate_memory_pressure.py --target 85 --duration 300

Integración de Prometeo

Configuración

1. Inicie la pila Prometheus usando Docker Compose:

docker compose up -d

Esto comenzará:

• Servidor Prometheus (accesible en http://localhost:9090 )

• Exportador de nodos (para métricas del host)

• cAdvisor (para métricas de contenedores)

2. Para realizar pruebas de estrés, puede iniciar el contenedor de estrés de memoria:

docker compose up -d --build memory-stress

O utilice el script de prueba del contenedor:

./scripts/container-memory-test.sh start

Scripts de configuración y restablecimiento de Docker

Este proyecto incluye múltiples configuraciones de Docker y scripts de reinicio para un funcionamiento confiable en diferentes entornos:

Configuraciones de Docker

• Configuración estándar ( docker-compose.yml ): utiliza Dockerfiles personalizados para Prometheus y Langflow para garantizar permisos consistentes en todos los sistemas.

• Configuración de red de puente ( docker-compose.bridge.yml ): configuración alternativa que utiliza redes de puente para entornos donde la red del host es problemática.

Archivos Docker personalizados para resolver problemas de permisos

El proyecto utiliza Dockerfiles personalizados tanto para Prometheus como para Langflow para resolver problemas de permisos comunes:

• Dockerfile.prometheus : configura la configuración de Prometheus con los permisos adecuados para el usuario nobody .

• Dockerfile.langflow : copia el directorio de componentes en el contenedor sin cambiar la propiedad del archivo, lo que permite que Langflow acceda a los componentes sin errores de permiso.

Este enfoque elimina la necesidad de realizar montajes de volumen que pueden generar conflictos de permisos entre diferentes máquinas y configuraciones de usuario.

Restablecer scripts

• Restablecer todos los servicios ( reset-all.sh ): restablece todos los contenedores con un solo comando.

  # Basic reset (rebuilds containers with existing volumes)
  ./reset-all.sh
  
  # Full reset (removes volumes and rebuilds containers)
  ./reset-all.sh --clean

• Reinicio de servicio individual :

  # Reset only Prometheus
  ./reset-prometheus.sh
  
  # Reset only Langflow
  ./reset-langflow.sh

Estos scripts garantizan que los contenedores estén configurados correctamente con los permisos correctos y los últimos cambios de código.

Solución de problemas

Si encuentra problemas de permisos:

1. Utilice los scripts de reinicio para reconstruir los contenedores

2. Verifique los registros con docker compose logs <service_name>

3. Asegúrese de que todos los componentes agregados a Langflow estén incluidos en Dockerfile.langflow

Implementación entre máquinas

Al implementar en una nueva máquina:

1. Clonar el repositorio

2. Hacer que los scripts de reinicio sean ejecutables: chmod +x *.sh

3. Ejecute el script de reinicio: ./reset-all.sh

Los Dockerfiles personalizados manejan automáticamente todos los problemas de permisos que puedan ocurrir en diferentes sistemas.

Uso del cliente Prometheus

La clase MCPAIComponent incluye capacidades de Prometheus:

from langflow import MCPAIComponent

# Initialize the client
mcp = MCPAIComponent(mcp_server_url="http://localhost:8000")

# Instant query (current metric values)
result = mcp.prometheus_query("up")

# Range query (metrics over time)
result = mcp.prometheus_query_range(
    query="rate(node_cpu_seconds_total{mode='system'}[1m])",
    start="2023-03-01T00:00:00Z",
    end="2023-03-01T01:00:00Z",
    step="15s"
)

# Get all labels
labels = mcp.prometheus_get_labels()

# Get label values
values = mcp.prometheus_get_label_values("job")

# Get targets
targets = mcp.prometheus_get_targets()

# Get alerts
alerts = mcp.prometheus_get_alerts()

Consultas útiles de PromQL

• Uso de CPU: rate(node_cpu_seconds_total{mode!="idle"}[1m])

• Uso de memoria: node_memory_MemTotal_bytes - node_memory_MemAvailable_bytes

• Uso del disco: node_filesystem_avail_bytes{mountpoint="/"} / node_filesystem_size_bytes{mountpoint="/"}

• Uso de CPU del contenedor: rate(container_cpu_usage_seconds_total[1m])

• Uso de memoria del contenedor: container_memory_usage_bytes

Puntos finales de API

Puntos finales de OpenAI

• GET /v1/models - Lista todos los modelos disponibles

• GET /v1/models/{model_id} - Obtener información sobre un modelo específico

• POST /v1/models/azure-gpt-4/completion - Generar la finalización de texto con Azure OpenAI

• POST /v1/models/azure-gpt-4/chat - Generar una respuesta de chat con Azure OpenAI

• POST /v1/models/openai-gpt-chat/chat - Generar una respuesta de chat usando el modelo de chat de OpenAI

• POST /v1/models/openai-gpt-completion/completion - Generar la finalización de texto utilizando el modelo de finalización de OpenAI

Puntos finales de integración de Git

• POST /v1/models/git-analyzer/analyze - Analizar un repositorio Git

• POST /v1/models/git-analyzer/search - Busca en un repositorio Git archivos que coincidan con un patrón

• POST /v1/models/git-analyzer/diff - Obtener la diferencia de la última confirmación en un repositorio

Puntos finales del sistema de archivos

• POST /v1/models/filesystem/list - Lista el contenido de un directorio

• POST /v1/models/filesystem/read - Leer el contenido de un archivo

• POST /v1/models/filesystem/read-multiple - Leer varios archivos a la vez

• POST /v1/models/filesystem/write - Escribe contenido en un archivo

• POST /v1/models/filesystem/edit - Editar un archivo con múltiples reemplazos

• POST /v1/models/filesystem/mkdir - Crear un directorio

• POST /v1/models/filesystem/move - Mover un archivo o directorio

• POST /v1/models/filesystem/search - Busca archivos que coincidan con un patrón

• POST /v1/models/filesystem/info - Obtener información sobre un archivo o directorio

Puntos finales de Prometheus

• POST /v1/models/prometheus/query - Ejecutar una consulta instantánea

• POST /v1/models/prometheus/query_range - Ejecutar una consulta de rango

• POST /v1/models/prometheus/series - Obtener datos de la serie

• GET /v1/models/prometheus/labels - Obtener todas las etiquetas disponibles

• POST /v1/models/prometheus/label_values - Obtener valores para una etiqueta específica

• GET /v1/models/prometheus/targets - Obtener todos los objetivos

• GET /v1/models/prometheus/rules - Obtener todas las reglas

• GET /v1/models/prometheus/alerts - Obtener todas las alertas

Uso del cliente

Puede utilizar MCPAIComponent en sus pipelines LangFlow proporcionando la URL del servidor MCP:

from langflow import MCPAIComponent

mcp = MCPAIComponent(mcp_server_url="http://localhost:8000")

# List available models
models = mcp.list_models()
print(models)

# Generate chat completion with OpenAI model
chat_response = mcp.chat(
    model_id="openai-gpt-chat",
    messages=[
        {"role": "system", "content": "You are a helpful assistant."},
        {"role": "user", "content": "Tell me a joke about programming."}
    ],
    max_tokens=100,
    temperature=0.7
)
print(chat_response)

# Generate text completion with OpenAI model
completion_response = mcp.completion(
    model_id="openai-gpt-completion",
    prompt="Write a function in Python to calculate the factorial of a number:",
    max_tokens=150,
    temperature=0.7
)
print(completion_response)

# Analyze a Git repository
repo_analysis = mcp.analyze_git_repo("https://github.com/username/repository")
print(repo_analysis)

# Search a Git repository
search_results = mcp.search_git_repo("https://github.com/username/repository", "def main")
print(search_results)

# Get the diff of the last commit
diff_info = mcp.get_git_diff("https://github.com/username/repository")
print(diff_info)

# List files in the current directory
dir_contents = mcp.list_directory()
print(dir_contents)

# Read a file
file_content = mcp.read_file("path/to/file.txt")
print(file_content)

# Write to a file
write_result = mcp.write_file("path/to/new_file.txt", "Hello, world!")
print(write_result)

# Search for files
search_result = mcp.search_files("*.py")
print(search_result)

Uso de la clase GitCodeAnalyzer

Para un análisis de Git más estructurado, puede utilizar la clase GitCodeAnalyzer :

from langflow_git_analyzer import GitCodeAnalyzer

# Initialize the analyzer
analyzer = GitCodeAnalyzer(mcp_server_url="http://localhost:8000")

# Analyze a repository
analyzer.analyze_repository("https://github.com/username/repository")

# Get a summary
summary = analyzer.get_repository_summary()
print(summary)

# Get AI recommendations
recommendations = analyzer.get_repository_recommendations()
print(recommendations)

# Analyze code patterns
pattern_analysis = analyzer.analyze_code_pattern("def process")
print(pattern_analysis)

# Get the last commit diff
diff_info = analyzer.get_last_commit_diff()
print(diff_info)

# Get a formatted summary of the diff
diff_summary = analyzer.get_formatted_diff_summary()
print(diff_summary)

# Get AI analysis of the commit changes
diff_analysis = analyzer.analyze_commit_diff()
print(diff_analysis)

Solución de problemas

Problemas de Prometeo

1. Verifique que Prometheus se esté ejecutando: docker ps | grep prometheus

2. Comprueba que puedes acceder a la interfaz de usuario de Prometheus: http://localhost:9090

3. Verifique que el servidor MCP esté en ejecución y sea accesible

4. Verifique los registros del servidor MCP para detectar errores

5. Pruebe primero consultas simples para verificar la conectividad (por ejemplo, consulta up )

Problemas de OpenAI

1. Verifique que sus claves API estén configuradas correctamente

2. Compruebe si hay problemas de limitación de velocidad o de cuota

3. Verifique que esté utilizando modelos compatibles con su clave API

Problemas con Git

1. Asegúrese de que la URL del repositorio de Git sea accesible

2. Compruebe si hay problemas de autenticación si utiliza repositorios privados

3. Asegúrese de que GitPython esté instalado correctamente