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

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

Clonar este repositorio
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

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)

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:

Utilice los scripts de reinicio para reconstruir los contenedores
Verifique los registros con docker compose logs <service_name>
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:

Clonar el repositorio
Hacer que los scripts de reinicio sean ejecutables: chmod +x *.sh
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

Verifique que Prometheus se esté ejecutando: docker ps | grep prometheus
Comprueba que puedes acceder a la interfaz de usuario de Prometheus: http://localhost:9090
Verifique que el servidor MCP esté en ejecución y sea accesible
Verifique los registros del servidor MCP para detectar errores
Pruebe primero consultas simples para verificar la conectividad (por ejemplo, consulta up )

Problemas de OpenAI

Verifique que sus claves API estén configuradas correctamente
Compruebe si hay problemas de limitación de velocidad o de cuota
Verifique que esté utilizando modelos compatibles con su clave API

Problemas con Git

Asegúrese de que la URL del repositorio de Git sea accesible
Compruebe si hay problemas de autenticación si utiliza repositorios privados
Asegúrese de que GitPython esté instalado correctamente

Model Control Plane (MCP) Server

Integrations

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

Estructura del proyecto

Requisitos

Instalación

Variables de entorno

Ejecución del servidor

Herramienta de prueba unificada

Pruebas individuales

Análisis avanzado de Git

Herramientas de análisis de memoria

Integración de Prometeo

Configuración

Scripts de configuración y restablecimiento de Docker

Configuraciones de Docker

Archivos Docker personalizados para resolver problemas de permisos

Restablecer scripts

Solución de problemas

Implementación entre máquinas

Uso del cliente Prometheus

Consultas útiles de PromQL

Puntos finales de API

Puntos finales de OpenAI

Puntos finales de integración de Git

Puntos finales del sistema de archivos

Puntos finales de Prometheus

Uso del cliente

Uso de la clase GitCodeAnalyzer

Solución de problemas

Problemas de Prometeo

Problemas de OpenAI

Problemas con Git

Related Resources

Appeared in Searches