MockLoop

Una plataforma de prueba de API nativa de IA para generar escenarios, ejecutar pruebas y analizar resultados.

Documentación

NOTA: Hemos implementado completamente SchemaPin para combatir copias cuestionables de este proyecto en Github y otros lugares. Asegúrate de validar que estás usando versiones de este repositorio y puedes usar SchemaPin para validar nuestros esquemas de herramientas: https://mockloop.com/.well-known/schemapin.json

MockLoop MCP - Plataforma de Pruebas Nativa para IA

La primera plataforma de pruebas de API nativa para IA del mundo impulsada por el Protocolo de Contexto de Modelos (MCP). MockLoop MCP revoluciona las pruebas de API con generación integral de escenarios impulsada por IA, ejecución automatizada de pruebas y capacidades de análisis inteligente.

🚀 Capacidades Revolucionarias: 5 Prompts de IA • 15 Recursos de Escenarios • 16 Herramientas de Pruebas • 10 Herramientas de Contexto • 4 Herramientas Principales • Integración MCP Completa

📚 Documentación: https://docs.mockloop.com
📦 Paquete PyPI: https://pypi.org/project/mockloop-mcp/
🐙 Repositorio GitHub: https://github.com/mockloop/mockloop-mcp

🌟 ¿Qué Hace Revolucionario a MockLoop MCP?

MockLoop MCP representa un cambio de paradigma en las pruebas de API, introduciendo la primera arquitectura de pruebas nativa para IA del mundo que combina:

🤖 Generación de Pruebas Impulsada por IA: 5 prompts MCP especializados para la creación inteligente de escenarios
📦 Paquetes de Escenarios Comunitarios: 15 recursos de pruebas seleccionados con arquitectura comunitaria
⚡ Ejecución Automatizada de Pruebas: 30 herramientas MCP integrales para flujos de trabajo de pruebas completos (16 de pruebas + 10 de contexto + 4 principales)
🔄 Pruebas con Estado: Gestión avanzada de contexto con GlobalContext y AgentContext
📊 Cumplimiento Empresarial: Registro de auditoría completo y seguimiento de cumplimiento normativo
🏗️ Arquitectura de Doble Puerto: Elimina conflictos de ruta /admin con puertos separados para API simulada y administración

🎯 Arquitectura Principal Nativa para IA

Registro de Auditoría MCP

Cumplimiento y seguimiento normativo de nivel empresarial

Trazabilidad completa de solicitudes/respuestas
Monitoreo de cumplimiento normativo
Métricas de rendimiento y análisis
Registro de eventos de seguridad

Prompts MCP (5 Capacidades Impulsadas por IA)

Generación inteligente de escenarios impulsada por IA

analyze_openapi_for_testing - Análisis integral de API para estrategias de prueba
generate_scenario_config - Configuración dinámica de escenarios de prueba
optimize_scenario_for_load - Optimización de pruebas de carga
generate_error_scenarios - Simulación de condiciones de error
generate_security_test_scenarios - Pruebas de vulnerabilidades de seguridad

Recursos MCP (15 Paquetes de Escenarios)

Escenarios de prueba impulsados por la comunidad con arquitectura avanzada

Escenarios de Pruebas de Carga: Simulación de tráfico de alto volumen
Paquetes de Simulación de Errores: Pruebas integrales de condiciones de error
Suites de Pruebas de Seguridad: Escenarios de evaluación de vulnerabilidades
Benchmarks de Rendimiento: Pruebas de rendimiento estandarizadas
Paquetes de Pruebas de Integración: Escenarios de pruebas entre servicios
Arquitectura Comunitaria: Compartición y validación colaborativa de escenarios

Herramientas MCP (16 Herramientas de Pruebas Automatizadas)

Capacidades completas de ejecución de pruebas automatizadas

Gestión de Escenarios (4 herramientas)

validate_scenario_config - Validación y verificación de escenarios
deploy_scenario - Despliegue automatizado de escenarios
switch_scenario - Cambio dinámico de escenarios
list_active_scenarios - Monitoreo de escenarios activos

Ejecución de Pruebas (4 herramientas)

execute_test_plan - Ejecución integral de planes de prueba
run_test_iteration - Gestión de iteraciones de pruebas individuales
run_load_test - Ejecución de pruebas de carga
run_security_test - Automatización de pruebas de seguridad

Análisis y Reportes (4 herramientas)

analyze_test_results - Análisis inteligente de resultados de pruebas
generate_test_report - Reportes integrales
compare_test_runs - Comparación de ejecuciones de pruebas y tendencias
get_performance_metrics - Recopilación de métricas de rendimiento

Gestión de Flujos de Trabajo (4 herramientas)

create_test_session - Inicialización de sesiones de prueba
end_test_session - Limpieza y finalización de sesiones
schedule_test_suite - Programación automatizada de pruebas
monitor_test_progress - Monitoreo de progreso en tiempo real

Gestión de Contexto MCP (10 Herramientas de Flujo de Trabajo con Estado)

Gestión avanzada de estado para flujos de trabajo de pruebas complejos

Creación y Gestión de Contexto

create_test_session_context - Gestión de estado de sesiones de prueba
create_workflow_context - Orquestación de flujos de trabajo complejos
create_agent_context - Gestión de estado de agentes de IA

Gestión de Datos

get_context_data - Recuperación de datos de contexto
update_context_data - Actualizaciones dinámicas de contexto
list_contexts_by_type - Descubrimiento y listado de contexto

Instantáneas y Recuperación

create_context_snapshot - Creación de instantáneas de estado
restore_context_snapshot - Capacidades de reversión de estado

Contexto Global

get_global_context_data - Compartición de datos entre sesiones
update_global_context_data - Gestión de estado global

🚀 Inicio Rápido

Comienza con la plataforma de pruebas nativa para IA más avanzada del mundo:

# 1. Install MockLoop MCP
pip install mockloop-mcp

# 2. Verify installation
mockloop-mcp --version

# 3. Configure with your MCP client (Cline, Claude Desktop, etc.)
# See configuration examples below

📋 Requisitos Previos

Python 3.10+
Gestor de paquetes Pip
Docker y Docker Compose (para servidores simulados en contenedores)
Un cliente compatible con MCP (Cline, Claude Desktop, etc.)

🔧 Instalación

Opción 1: Instalar desde PyPI (Recomendado)

# Install the latest stable version
pip install mockloop-mcp

# Or install with optional dependencies
pip install mockloop-mcp[dev]   # Development tools
pip install mockloop-mcp[docs]  # Documentation tools
pip install mockloop-mcp[all]   # All optional dependencies

# Verify installation
mockloop-mcp --version

Opción 2: Instalación de Desarrollo

# Clone the repository
git clone https://github.com/mockloop/mockloop-mcp.git
cd mockloop-mcp

# Create and activate virtual environment
python3 -m venv .venv
source .venv/bin/activate  # On Windows: .venv\Scripts\activate

# Install in development mode
pip install -e ".[dev]"

⚙️ Configuración

Configuración del Cliente MCP

Cline (Extensión de VS Code)

Añade a tu archivo de configuración MCP de Cline:

{
  "mcpServers": {
    "MockLoopLocal": {
      "autoApprove": [],
      "disabled": false,
      "timeout": 60,
      "command": "mockloop-mcp",
      "args": [],
      "transportType": "stdio"
    }
  }
}

Claude Desktop

Añade a tu configuración de Claude Desktop:

{
  "mcpServers": {
    "mockloop": {
      "command": "mockloop-mcp",
      "args": []
    }
  }
}

Instalaciones en Entornos Virtuales

Para instalaciones en entornos virtuales, usa la ruta completa de Python:

{
  "mcpServers": {
    "MockLoopLocal": {
      "command": "/path/to/your/venv/bin/python",
      "args": ["-m", "mockloop_mcp"],
      "transportType": "stdio"
    }
  }
}

🛠️ Herramientas MCP Disponibles

Generación Principal de Mocks

`generate_mock_api`

Genera servidores mock FastAPI sofisticados con arquitectura de doble puerto.

Parámetros:

spec_url_or_path (cadena, obligatorio): URL de especificación de API o ruta de archivo local
output_dir_name (cadena, opcional): Nombre del directorio de salida
auth_enabled (booleano, opcional): Habilitar middleware de autenticación (predeterminado: true)
webhooks_enabled (booleano, opcional): Habilitar soporte de webhooks (predeterminado: true)
admin_ui_enabled (booleano, opcional): Habilitar interfaz de administración (predeterminado: true)
storage_enabled (booleano, opcional): Habilitar funcionalidad de almacenamiento (predeterminado: true)

Arquitectura Revolucionaria de Doble Puerto:

Puerto de API Simulada: Sirve tus endpoints de API (predeterminado: 8000)
Puerto de Interfaz de Administración: Interfaz de administración separada (predeterminado: 8001)
Resolución de Conflictos: Elimina conflictos de ruta /admin en especificaciones OpenAPI
Seguridad Mejorada: Control de acceso y aislamiento basado en puertos

Análisis Avanzado

`query_mock_logs`

Consulta y analiza registros de solicitudes con información impulsada por IA.

Parámetros:

server_url (cadena, obligatorio): URL del servidor mock
limit (entero, opcional): Máximo de registros a devolver (predeterminado: 100)
offset (entero, opcional): Desplazamiento de paginación (predeterminado: 0)
method (cadena, opcional): Filtrar por método HTTP
path_pattern (cadena, opcional): Patrón regex para filtrado de rutas
time_from (cadena, opcional): Filtro de hora de inicio (formato ISO)
time_to (cadena, opcional): Filtro de hora de fin (formato ISO)
include_admin (booleano, opcional): Incluir solicitudes de administración (predeterminado: false)
analyze (booleano, opcional): Realizar análisis de IA (predeterminado: true)

Análisis Impulsado por IA:

Métricas de rendimiento (tiempos de respuesta P95/P99)
Análisis y categorización de tasas de error
Detección de patrones de tráfico
Recomendaciones automatizadas de depuración
Correlación y seguimiento de sesiones

`discover_mock_servers`

Descubrimiento inteligente de servidores con soporte de arquitectura de doble puerto.

Parámetros:

ports (matriz, opcional): Puertos a escanear (predeterminado: puertos comunes)
check_health (booleano, opcional): Realizar comprobaciones de salud (predeterminado: true)
include_generated (booleano, opcional): Incluir mocks generados (predeterminado: true)

Descubrimiento Avanzado:

Detección automática de arquitectura (puerto único vs. doble puerto)
Monitoreo de estado de salud
Correlación y coincidencia de servidores
Análisis de uso de puertos

`manage_mock_data`

Gestión dinámica de respuestas sin reiniciar el servidor.

Parámetros:

server_url (cadena, obligatorio): URL del servidor mock
operation (cadena, obligatorio): Tipo de operación ("update_response", "create_scenario", "switch_scenario", "list_scenarios")
endpoint_path (cadena, opcional): Ruta del endpoint de API
response_data (objeto, opcional): Nuevos datos de respuesta
scenario_name (cadena, opcional): Nombre del escenario
scenario_config (objeto, opcional): Configuración del escenario

Capacidades Dinámicas:

Actualizaciones de respuestas en tiempo real
Pruebas basadas en escenarios
Gestión de configuración en tiempo de ejecución
Modificaciones sin tiempo de inactividad

🌐 Funcionalidad de Proxy MCP

MockLoop MCP incluye capacidades de proxy revolucionarias que permiten cambiar sin problemas entre entornos de API simulados y en vivo. Esta potente funcionalidad transforma tu flujo de trabajo de pruebas al proporcionar:

Capacidades Principales del Proxy

🔄 Cambio de Modo Sin Problemas: Transición entre modos mock, proxy e híbrido sin cambios de código
🎯 Enrutamiento Inteligente: Enrutamiento inteligente de solicitudes basado en reglas y condiciones configurables
🔐 Autenticación Universal: Soporte para API Key, Bearer Token, Basic Auth y OAuth2
📊 Comparación de Respuestas: Comparación automatizada entre respuestas mock y de API en vivo
⚡ Cambio Sin Tiempo de Inactividad: Cambia de modo dinámicamente sin interrupción del servicio

Modos Operativos

Modo Mock (`MOCK`)

Todas las solicitudes son manejadas por respuestas mock generadas
Entorno de pruebas predecible y consistente
Ideal para desarrollo temprano y pruebas aisladas
Sin dependencias externas ni llamadas de red

Modo Proxy (`PROXY`)

Todas las solicitudes se reenvían a endpoints de API en vivo
Datos en tiempo real y respuestas auténticas
Capacidades completas de pruebas de integración
Operación dependiente de red con credenciales en vivo

Modo Híbrido (`HYBRID`)

Enrutamiento inteligente entre mock y proxy basado en reglas
Cambio condicional basado en patrones de solicitud, encabezados o parámetros
Migración gradual de entornos mock a entornos en vivo
Pruebas A/B y proxy selectivo de endpoints

Ejemplo de Inicio Rápido

from mockloop_mcp.mcp_tools import create_mcp_plugin

# Create a proxy-enabled plugin
plugin_result = await create_mcp_plugin(
    spec_url_or_path="https://api.example.com/openapi.json",
    mode="hybrid",  # Start with hybrid mode
    plugin_name="example_api",
    target_url="https://api.example.com",
    auth_config={
        "auth_type": "bearer_token",
        "credentials": {"token": "your-token"}
    },
    routing_rules=[
        {
            "pattern": "/api/critical/*",
            "mode": "proxy",  # Critical endpoints use live API
            "priority": 10
        },
        {
            "pattern": "/api/dev/*",
            "mode": "mock",   # Development endpoints use mocks
            "priority": 5
        }
    ]
)

Funcionalidades Avanzadas

🔍 Validación de Respuestas: Compara respuestas mock vs. en vivo para verificar consistencia
📈 Monitoreo de Rendimiento: Rastrea tiempos de respuesta y rendimiento entre modos
🛡️ Manejo de Errores: Mecanismos de respaldo elegantes y políticas de reintento
🎛️ Configuración Dinámica: Cambio de modo en tiempo de ejecución y actualizaciones de reglas
📋 Registro de Auditoría: Seguimiento completo de solicitudes/respuestas en todos los modos

Soporte de Autenticación

El sistema de proxy soporta esquemas de autenticación integrales:

API Key: Autenticación basada en encabezado, parámetro de consulta o cookie
Bearer Token: Soporte de tokens OAuth2 y JWT
Basic Auth: Combinaciones de nombre de usuario/contraseña
OAuth2: Flujo OAuth2 completo con renovación de tokens
Personalizado: Manejadores de autenticación extensibles para esquemas propietarios

Casos de Uso

Flujo de trabajo de desarrollo: Comience con mocks, introduzca gradualmente APIs en vivo
Pruebas de integración: Valide contra servicios reales manteniendo el aislamiento de pruebas
Pruebas de rendimiento: Compare las características de rendimiento entre APIs mock y en vivo
Validación de staging: Asegúrese de que las respuestas mock coincidan con el comportamiento de la API de producción
Implementaciones híbridas: Enrute operaciones críticas a APIs en vivo y otras a mocks

📚 Guía completa: Para configuración detallada, ejemplos y mejores prácticas, consulte la Guía de MCP Proxy.

🤖 Integración con Frameworks de IA

MockLoop MCP proporciona integración nativa con frameworks de IA populares:

Integración con LangGraph

from langgraph.graph import StateGraph, END
from mockloop_mcp import MockLoopClient

# Initialize MockLoop client
mockloop = MockLoopClient()

def setup_ai_testing(state):
    """AI-driven test setup"""
    # Generate mock API with AI analysis
    result = mockloop.generate_mock_api(
        spec_url_or_path="https://api.example.com/openapi.json",
        output_dir_name="ai_test_environment"
    )
    
    # Use AI prompts for scenario generation
    scenarios = mockloop.analyze_openapi_for_testing(
        api_spec=state["api_spec"],
        analysis_depth="comprehensive",
        include_security_tests=True
    )
    
    state["mock_server_url"] = "http://localhost:8000"
    state["test_scenarios"] = scenarios
    return state

def execute_ai_tests(state):
    """Execute AI-generated test scenarios"""
    # Deploy AI-generated scenarios
    for scenario in state["test_scenarios"]:
        mockloop.deploy_scenario(
            server_url=state["mock_server_url"],
            scenario_config=scenario
        )
        
        # Execute load tests with AI optimization
        results = mockloop.run_load_test(
            server_url=state["mock_server_url"],
            scenario_name=scenario["name"],
            duration=300,
            concurrent_users=100
        )
        
        # AI-powered result analysis
        analysis = mockloop.analyze_test_results(
            test_results=results,
            include_recommendations=True
        )
        
        state["test_results"].append(analysis)
    
    return state

# Build AI-native testing workflow
workflow = StateGraph(dict)
workflow.add_node("setup_ai_testing", setup_ai_testing)
workflow.add_node("execute_ai_tests", execute_ai_tests)
workflow.set_entry_point("setup_ai_testing")
workflow.add_edge("setup_ai_testing", "execute_ai_tests")
workflow.add_edge("execute_ai_tests", END)

app = workflow.compile()

Pruebas Multi-Agente con CrewAI

from crewai import Agent, Task, Crew
from mockloop_mcp import MockLoopClient

# Initialize MockLoop client
mockloop = MockLoopClient()

# AI Testing Specialist Agent
api_testing_agent = Agent(
    role='AI API Testing Specialist',
    goal='Generate and execute comprehensive AI-driven API tests',
    backstory='Expert in AI-native testing with MockLoop MCP integration',
    tools=[
        mockloop.generate_mock_api,
        mockloop.analyze_openapi_for_testing,
        mockloop.generate_scenario_config
    ]
)

# Performance Analysis Agent
performance_agent = Agent(
    role='AI Performance Analyst',
    goal='Analyze API performance with AI-powered insights',
    backstory='Specialist in AI-driven performance analysis and optimization',
    tools=[
        mockloop.run_load_test,
        mockloop.get_performance_metrics,
        mockloop.analyze_test_results
    ]
)

# Security Testing Agent
security_agent = Agent(
    role='AI Security Testing Expert',
    goal='Conduct AI-driven security testing and vulnerability assessment',
    backstory='Expert in AI-powered security testing methodologies',
    tools=[
        mockloop.generate_security_test_scenarios,
        mockloop.run_security_test,
        mockloop.compare_test_runs
    ]
)

# Define AI-driven tasks
ai_setup_task = Task(
    description='Generate AI-native mock API with comprehensive testing scenarios',
    agent=api_testing_agent,
    expected_output='Mock server with AI-generated test scenarios deployed'
)

performance_task = Task(
    description='Execute AI-optimized performance testing and analysis',
    agent=performance_agent,
    expected_output='Comprehensive performance analysis with AI recommendations'
)

security_task = Task(
    description='Conduct AI-driven security testing and vulnerability assessment',
    agent=security_agent,
    expected_output='Security test results with AI-powered threat analysis'
)

# Create AI testing crew
ai_testing_crew = Crew(
    agents=[api_testing_agent, performance_agent, security_agent],
    tasks=[ai_setup_task, performance_task, security_task],
    verbose=True
)

# Execute AI-native testing workflow
results = ai_testing_crew.kickoff()

Herramientas de Pruebas de IA con LangChain

from langchain.agents import Tool, AgentExecutor, create_react_agent
from langchain.prompts import PromptTemplate
from langchain_openai import ChatOpenAI
from mockloop_mcp import MockLoopClient

# Initialize MockLoop client
mockloop = MockLoopClient()

# AI-Native Testing Tools
def ai_generate_mock_api(spec_path: str) -> str:
    """Generate AI-enhanced mock API with intelligent scenarios"""
    # Generate mock API
    result = mockloop.generate_mock_api(spec_url_or_path=spec_path)
    
    # Use AI to analyze and enhance
    analysis = mockloop.analyze_openapi_for_testing(
        api_spec=spec_path,
        analysis_depth="comprehensive",
        include_security_tests=True
    )
    
    return f"AI-enhanced mock API generated: {result}\nAI Analysis: {analysis['summary']}"

def ai_execute_testing_workflow(server_url: str) -> str:
    """Execute comprehensive AI-driven testing workflow"""
    # Create test session context
    session = mockloop.create_test_session_context(
        session_name="ai_testing_session",
        configuration={"ai_enhanced": True}
    )
    
    # Generate and deploy AI scenarios
    scenarios = mockloop.generate_scenario_config(
        api_spec=server_url,
        scenario_types=["load", "error", "security"],
        ai_optimization=True
    )
    
    results = []
    for scenario in scenarios:
        # Deploy scenario
        mockloop.deploy_scenario(
            server_url=server_url,
            scenario_config=scenario
        )
        
        # Execute tests with AI monitoring
        test_result = mockloop.execute_test_plan(
            server_url=server_url,
            test_plan=scenario["test_plan"],
            ai_monitoring=True
        )
        
        results.append(test_result)
    
    # AI-powered analysis
    analysis = mockloop.analyze_test_results(
        test_results=results,
        include_recommendations=True,
        ai_insights=True
    )
    
    return f"AI testing workflow completed: {analysis['summary']}"

# Create LangChain tools
ai_testing_tools = [
    Tool(
        name="AIGenerateMockAPI",
        func=ai_generate_mock_api,
        description="Generate AI-enhanced mock API with intelligent testing scenarios"
    ),
    Tool(
        name="AIExecuteTestingWorkflow",
        func=ai_execute_testing_workflow,
        description="Execute comprehensive AI-driven testing workflow with intelligent analysis"
    )
]

# Create AI testing agent
llm = ChatOpenAI(temperature=0)
ai_testing_prompt = PromptTemplate.from_template("""
You are an AI-native testing assistant powered by MockLoop MCP.
You have access to revolutionary AI-driven testing capabilities including:
- AI-powered scenario generation
- Intelligent test execution
- Advanced performance analysis
- Security vulnerability assessment
- Stateful workflow management

Tools available: {tools}
Tool names: {tool_names}

Question: {input}
{agent_scratchpad}
""")

agent = create_react_agent(llm, ai_testing_tools, ai_testing_prompt)
agent_executor = AgentExecutor(agent=agent, tools=ai_testing_tools, verbose=True)

# Execute AI-native testing
response = agent_executor.invoke({
    "input": "Generate a comprehensive AI-driven testing environment for a REST API and execute full testing workflow"
})

🏗️ Arquitectura de Doble Puerto

MockLoop MCP introduce una revolucionaria arquitectura de doble puerto que elimina conflictos comunes y mejora la seguridad:

Beneficios de la Arquitectura

🔒 Seguridad Mejorada: Separación completa de la API simulada y la funcionalidad de administración
⚡ Cero Conflictos: Elimina conflictos de rutas /admin en especificaciones OpenAPI
📊 Analíticas Limpias: Las llamadas de administración no aparecen en las métricas de la API simulada
🔄 Escalado Independiente: Escale la API simulada y los servicios de administración por separado
🛡️ Control de Acceso Basado en Puertos: Seguridad mejorada mediante aislamiento de red

Configuración de Puertos

# Generate mock with dual-port architecture
result = mockloop.generate_mock_api(
    spec_url_or_path="https://api.example.com/openapi.json",
    business_port=8000,  # Mocked API port
    admin_port=8001,     # Admin UI port
    admin_ui_enabled=True
)

Puntos de Acceso

API Simulada: http://localhost:8000 - Sus endpoints de API
Interfaz de Administración: http://localhost:8001 - Interfaz de gestión
Documentación de API: http://localhost:8000/docs - Interfaz Swagger interactiva
Verificación de Salud: http://localhost:8000/health - Estado del servidor

📊 Funciones Empresariales

Cumplimiento y Registro de Auditoría

MockLoop MCP proporciona funciones de cumplimiento de nivel empresarial:

Rastros de Auditoría Completos: Cada solicitud/respuesta registrada con metadatos
Cumplimiento Normativo: Soporte de cumplimiento GDPR, SOX, HIPAA
Métricas de Rendimiento: Tiempos de respuesta P95/P99, tasas de error
Monitoreo de Seguridad: Detección y análisis de amenazas
Seguimiento de Sesiones: Correlación y análisis entre solicitudes

Analíticas Avanzadas

Información Impulsada por IA: Análisis y recomendaciones inteligentes
Detección de Patrones de Tráfico: Detección automatizada de anomalías
Optimización de Rendimiento: Recomendaciones de rendimiento impulsadas por IA
Análisis de Errores: Categorización y resolución inteligente de errores
Análisis de Tendencias: Tendencias históricas de rendimiento y uso

🔄 Flujos de Trabajo de Pruebas con Estado

MockLoop MCP admite flujos de trabajo de pruebas complejos y con estado mediante gestión avanzada de contexto:

Tipos de Contexto

Contexto de Sesión de Prueba: Mantenga el estado entre ejecuciones de pruebas
Contexto de Flujo de Trabajo: Orquestación compleja de pruebas de múltiples pasos
Contexto de Agente: Gestión y coordinación del estado de agentes de IA
Contexto Global: Compartición y persistencia de datos entre sesiones

Ejemplo: Pruebas de Comercio Electrónico con Estado

# Create test session context
session = mockloop.create_test_session_context(
    session_name="ecommerce_integration_test",
    configuration={
        "test_type": "integration",
        "environment": "staging",
        "ai_enhanced": True
    }
)

# Create workflow context for multi-step testing
workflow = mockloop.create_workflow_context(
    workflow_name="user_journey_test",
    parent_context=session["context_id"],
    steps=[
        "user_registration",
        "product_browsing",
        "cart_management",
        "checkout_process",
        "order_fulfillment"
    ]
)

# Execute stateful test workflow
for step in workflow["steps"]:
    # Update context with step data
    mockloop.update_context_data(
        context_id=workflow["context_id"],
        data={"current_step": step, "timestamp": datetime.now()}
    )
    
    # Execute step-specific tests
    test_result = mockloop.execute_test_plan(
        server_url="http://localhost:8000",
        test_plan=f"{step}_test_plan",
        context_id=workflow["context_id"]
    )
    
    # Create snapshot for rollback capability
    snapshot = mockloop.create_context_snapshot(
        context_id=workflow["context_id"],
        snapshot_name=f"{step}_completion"
    )

# Analyze complete workflow results
final_analysis = mockloop.analyze_test_results(
    test_results=workflow["results"],
    context_id=workflow["context_id"],
    include_recommendations=True
)

🚀 Ejecución de Servidores Mock Generados

Usando Docker Compose (Recomendado)

# Navigate to generated mock directory
cd generated_mocks/your_api_mock

# Start with dual-port architecture
docker-compose up --build

# Access points:
# Mocked API: http://localhost:8000
# Admin UI: http://localhost:8001

Usando Uvicorn Directamente

# Install dependencies
pip install -r requirements_mock.txt

# Start the mock server
uvicorn main:app --reload --port 8000

Acceso a Funciones Mejoradas

Interfaz de Administración: http://localhost:8001 - Interfaz de gestión mejorada
Documentación de API: http://localhost:8000/docs - Interfaz Swagger interactiva
Verificación de Salud: http://localhost:8000/health - Estado y métricas del servidor
Analíticas de Registros: http://localhost:8001/api/logs/search - Consulta avanzada de registros
Métricas de Rendimiento: http://localhost:8001/api/logs/analyze - Información impulsada por IA
Gestión de Escenarios: http://localhost:8001/api/mock-data/scenarios - Pruebas dinámicas

📈 Rendimiento y Escalabilidad

MockLoop MCP está diseñado para rendimiento a escala empresarial:

Métricas de Rendimiento

Tiempos de Respuesta: Seguimiento de percentiles P50, P95, P99
Rendimiento: Monitoreo de solicitudes por segundo
Tasas de Error: Análisis integral de errores
Uso de Recursos: Monitoreo de memoria, CPU y red
Concurrencia: Soporte de pruebas de carga multiusuario

Funciones de Escalabilidad

Escalado Horizontal: Soporte de implementación multi-instancia
Balanceo de Carga: Capacidades integradas de balanceo de carga
Almacenamiento en Caché: Caché inteligente de respuestas
Optimización de Base de Datos: Soporte eficiente de SQLite y PostgreSQL
Orquestación de Contenedores: Listo para Kubernetes y Docker Swarm

🔒 Funciones de Seguridad

Seguridad Integrada

Middleware de Autenticación: Mecanismos de autenticación configurables
Limitación de Tasa: Previene abusos y ataques DoS
Validación de Entrada: Validación integral de solicitudes
Encabezados de Seguridad: CORS, CSP y encabezados de seguridad
Registro de Auditoría: Registro completo de eventos de seguridad

Pruebas de Seguridad

Evaluación de Vulnerabilidades: Pruebas de seguridad impulsadas por IA
Pruebas de Penetración: Generación automatizada de escenarios de seguridad
Verificación de Cumplimiento: Verificación de cumplimiento de estándares de seguridad
Modelado de Amenazas: Análisis de amenazas impulsado por IA
Informes de Seguridad: Analíticas de seguridad integrales

🔐 Integración SchemaPin - Verificación Criptográfica de Esquemas

MockLoop MCP ahora incluye integración SchemaPin - el primer sistema de verificación criptográfica de esquemas de la industria para herramientas MCP, que previene ataques "MCP Rug Pull" mediante verificación de firmas ECDSA y fijación de claves Trust-On-First-Use (TOFU).

Mejora de Seguridad Revolucionaria

La integración SchemaPin transforma MockLoop MCP en la plataforma de pruebas MCP más segura al proporcionar:

🔐 Verificación Criptográfica: Las firmas ECDSA P-256 garantizan la integridad del esquema
🔑 Fijación de Claves TOFU: Descubrimiento y fijación automática de claves para dominios confiables
📋 Aplicación de Políticas: Políticas de seguridad configurables (modos enforce/warn/log)
📊 Auditoría Integral: Registros de verificación completos para cumplimiento
🔄 Reversión Elegante: Funciona con o sin la biblioteca SchemaPin
🏗️ Arquitectura Híbrida: Integración perfecta con sistemas MockLoop existentes

Configuración de Inicio Rápido

from mockloop_mcp.schemapin import SchemaPinConfig, SchemaVerificationInterceptor

# Basic configuration
config = SchemaPinConfig(
    enabled=True,
    policy_mode="warn",  # enforce, warn, or log
    auto_pin_keys=False,
    trusted_domains=["api.example.com"],
    interactive_mode=False
)

# Initialize verification
interceptor = SchemaVerificationInterceptor(config)

# Verify tool schema
result = await interceptor.verify_tool_schema(
    tool_name="database_query",
    schema=tool_schema,
    signature="base64_encoded_signature",
    domain="api.example.com"
)

if result.valid:
    print("✓ Schema verification successful")
else:
    print(f"✗ Verification failed: {result.error}")

Configuración de Producción

# Production-ready configuration
config = SchemaPinConfig(
    enabled=True,
    policy_mode="enforce",  # Block execution on verification failure
    auto_pin_keys=True,     # Auto-pin keys for trusted domains
    key_pin_storage_path="/secure/path/keys.db",
    discovery_timeout=60,
    cache_ttl=7200,
    trusted_domains=[
        "api.corp.com",
        "tools.internal.com"
    ],
    well_known_endpoints={
        "api.corp.com": "https://api.corp.com/.well-known/schemapin.json"
    },
    revocation_check=True,
    interactive_mode=False
)

Beneficios de Seguridad

Protección contra MCP Rug Pull

SchemaPin evita que actores maliciosos modifiquen esquemas de herramientas sin ser detectados:

Firmas Criptográficas: Cada esquema de herramienta está firmado criptográficamente
Fijación de Claves: El modelo TOFU previene ataques de intermediario (man-in-the-middle)
Rastros de Auditoría: Registros de verificación completos para análisis de seguridad
Aplicación de Políticas: Respuestas configurables ante fallos de verificación

Cumplimiento y Gobernanza

Cumplimiento Normativo: Los registros de auditoría respaldan los requisitos GDPR, SOX, HIPAA
Seguridad Empresarial: Integración con frameworks de seguridad existentes
Gestión de Riesgos: Políticas de seguridad configurables para diferentes entornos
Detección de Amenazas: Detección automatizada de intentos de manipulación de esquemas

Ejemplos de Integración

Verificación Básica de Herramientas

# Verify a single tool
from mockloop_mcp.schemapin import SchemaVerificationInterceptor

interceptor = SchemaVerificationInterceptor(config)
result = await interceptor.verify_tool_schema(
    "api_call", tool_schema, signature, "api.example.com"
)

Verificación por Lotes

# Verify multiple tools efficiently
from mockloop_mcp.schemapin import SchemaPinWorkflowManager

workflow = SchemaPinWorkflowManager(config)
results = await workflow.verify_tool_batch([
    {"name": "tool1", "schema": schema1, "signature": sig1, "domain": "api.com"},
    {"name": "tool2", "schema": schema2, "signature": sig2, "domain": "api.com"}
])

Integración con MCP Proxy

# Integrate with MCP proxy for seamless security
class SecureMCPProxy:
    def __init__(self, config):
        self.interceptor = SchemaVerificationInterceptor(config)
    
    async def proxy_tool_request(self, tool_name, schema, signature, domain, data):
        # Verify schema before execution
        result = await self.interceptor.verify_tool_schema(
            tool_name, schema, signature, domain
        )
        
        if not result.valid:
            return {"error": "Schema verification failed"}
        
        # Execute tool with verified schema
        return await self.execute_tool(tool_name, data)

Modos de Política

Modo Enforce (Aplicar)

config = SchemaPinConfig(policy_mode="enforce")
# Blocks execution on verification failure
# Recommended for production critical tools

Modo Warn (Advertir)

config = SchemaPinConfig(policy_mode="warn")
# Logs warnings but allows execution
# Recommended for gradual rollout

Modo Log (Registrar)

config = SchemaPinConfig(policy_mode="log")
# Logs events without blocking
# Recommended for monitoring and testing

Gestión de Claves

Trust-On-First-Use (TOFU)

# Automatic key discovery and pinning
key_manager = KeyPinningManager("keys.db")

# Pin key for trusted tool
success = key_manager.pin_key(
    tool_id="api.example.com/database_query",
    domain="api.example.com",
    public_key_pem=discovered_key,
    metadata={"developer": "Example Corp"}
)

# Check if key is pinned
if key_manager.is_key_pinned("api.example.com/database_query"):
    print("Key is pinned and trusted")

Descubrimiento de Claves

SchemaPin descubre automáticamente claves públicas mediante endpoints .well-known:

https://api.example.com/.well-known/schemapin.json

Formato esperado:

{
  "public_key": "-----BEGIN PUBLIC KEY-----\n...\n-----END PUBLIC KEY-----",
  "algorithm": "ES256",
  "created_at": "2023-01-01T00:00:00Z"
}

Auditoría y Cumplimiento

Registro Integral

from mockloop_mcp.schemapin import SchemaPinAuditLogger

audit_logger = SchemaPinAuditLogger("audit.db")

# Verification events are automatically logged
stats = audit_logger.get_verification_stats()
print(f"Total verifications: {stats['total_verifications']}")
print(f"Success rate: {stats['successful_verifications'] / stats['total_verifications'] * 100:.1f}%")

Informes de Cumplimiento

# Generate compliance reports
from mockloop_mcp.mcp_compliance import MCPComplianceReporter

reporter = MCPComplianceReporter("audit.db")
report = reporter.generate_schemapin_compliance_report()

print(f"Compliance score: {report['compliance_score']:.1f}%")
print(f"Verification coverage: {report['verification_statistics']['unique_tools']} tools")

Documentación y Ejemplos

📚 Guía de Integración Completa: docs/guides/schemapin-integration.md
🔧 Ejemplo de Uso Básico: examples/schemapin/basic_usage.py
⚡ Patrones Avanzados: examples/schemapin/advanced_usage.py
🏗️ Documentación de Arquitectura: SchemaPin_MockLoop_Integration_Architecture.md
🧪 Cobertura de Pruebas: 56 pruebas integrales (42 unitarias + 14 de integración)

Migración para Usuarios Existentes

La integración SchemaPin es completamente compatible con versiones anteriores:

Configuración Opt-in: SchemaPin está deshabilitado por defecto
Sin Cambios Disruptivos: Las herramientas existentes continúan funcionando sin cambios
Implementación Gradual: Comience con el modo log, avance a warn, luego enforce
Cero Tiempo de Inactividad: Habilite la verificación sin interrupción del servicio

# Migration example: gradual rollout
# Phase 1: Monitoring (log mode)
config = SchemaPinConfig(enabled=True, policy_mode="log")

# Phase 2: Warnings (warn mode)
config = SchemaPinConfig(enabled=True, policy_mode="warn")

# Phase 3: Enforcement (enforce mode)
config = SchemaPinConfig(enabled=True, policy_mode="enforce")

Impacto en el Rendimiento

SchemaPin está diseñado para un impacto mínimo en el rendimiento:

Tiempo de Verificación: ~5-15ms por herramienta (resultados en caché)
Uso de Memoria: <10MB de memoria adicional
Sobrecarga de Red: Descubrimiento de claves solo en el primer uso
Tamaño de Base de Datos: ~1KB por clave fijada

Casos de Uso

Equipos de Desarrollo

Desarrollo Seguro: Verifique esquemas de herramientas durante el desarrollo
Revisión de Código: Garantice la integridad del esquema en pull requests
Pruebas: Valide el comportamiento de las herramientas con esquemas verificados

Seguridad Empresarial

Prevención de Amenazas: Bloquee modificaciones maliciosas de esquemas
Cumplimiento: Cumpla los requisitos normativos con rastros de auditoría
Gestión de Riesgos: Políticas de seguridad configurables
Respuesta a Incidentes: Registros detallados para análisis de seguridad

DevOps y CI/CD

Seguridad de Pipelines: Verifique esquemas en pipelines de implementación
Promoción de Entornos: Garantice la consistencia del esquema entre entornos
Monitoreo: Monitoreo continuo de verificación
Automatización: Aplicación automatizada de políticas de seguridad

##️ Desarrollo Futuro

Próximas Funciones 🚧

Capacidades de IA Mejoradas

Modelos ML Avanzados: Entrenamiento de modelos personalizados para pruebas de API
Analíticas Predictivas: Predicción de fallos impulsada por IA
Generación Inteligente de Pruebas: Escenarios de prueba auto-mejorables
Pruebas en Lenguaje Natural: Descripciones de prueba en lenguaje sencillo

Soporte Extendido de Protocolos

Soporte GraphQL: Pruebas nativas de API GraphQL
Integración gRPC: Soporte de pruebas de protocol buffers
Pruebas WebSocket: Pruebas de comunicación en tiempo real
Pruebas Basadas en Eventos: Pruebas de API asíncronas y basadas en eventos

Integración Empresarial

Integración CI/CD: Integración nativa con pipelines
Plataformas de Monitoreo: Integración con Datadog, New Relic, Prometheus
Proveedores de Identidad: Integración de SSO y autenticación empresarial
Frameworks de Cumplimiento: Soporte extendido de cumplimiento normativo

🤝 Contribuciones

¡Damos la bienvenida a contribuciones a MockLoop MCP! Consulte nuestras Pautas de Contribución para más detalles.

Configuración de Desarrollo

# Fork and clone the repository
git clone https://github.com/your-username/mockloop-mcp.git
cd mockloop-mcp

# Create development environment
python3 -m venv .venv
source .venv/bin/activate

# Install development dependencies
pip install -e ".[dev]"

# Run tests
pytest tests/

# Run quality checks
ruff check src/
bandit -r src/

Comunidad

Repositorio de GitHub: mockloop/mockloop-mcp
Issues e Informes de Errores: GitHub Issues
Solicitudes de Funciones: GitHub Issues
Documentación: docs.mockloop.com

📄 Licencia

MockLoop MCP está licenciado bajo la Licencia MIT.

🎉 ¡Comience Hoy!

¿Listo para revolucionar sus pruebas de API con la primera plataforma de pruebas nativa de IA del mundo?

pip install mockloop-mcp

Únase a la revolución de pruebas nativas de IA y experimente el futuro de las pruebas de API con MockLoop MCP!

🚀 Comience Ahora →

MockLoop

Documentación

MockLoop MCP - Plataforma de Pruebas Nativa para IA

🌟 ¿Qué Hace Revolucionario a MockLoop MCP?

🎯 Arquitectura Principal Nativa para IA

Registro de Auditoría MCP

Prompts MCP (5 Capacidades Impulsadas por IA)

Recursos MCP (15 Paquetes de Escenarios)

Herramientas MCP (16 Herramientas de Pruebas Automatizadas)

Gestión de Escenarios (4 herramientas)

Ejecución de Pruebas (4 herramientas)

Análisis y Reportes (4 herramientas)

Gestión de Flujos de Trabajo (4 herramientas)

Gestión de Contexto MCP (10 Herramientas de Flujo de Trabajo con Estado)

Creación y Gestión de Contexto

Gestión de Datos

Instantáneas y Recuperación

Contexto Global

🚀 Inicio Rápido

📋 Requisitos Previos

🔧 Instalación

Opción 1: Instalar desde PyPI (Recomendado)

Opción 2: Instalación de Desarrollo

⚙️ Configuración

Configuración del Cliente MCP

Cline (Extensión de VS Code)

Claude Desktop

Instalaciones en Entornos Virtuales

🛠️ Herramientas MCP Disponibles

Generación Principal de Mocks

generate_mock_api

Análisis Avanzado

query_mock_logs

discover_mock_servers

manage_mock_data

🌐 Funcionalidad de Proxy MCP

Capacidades Principales del Proxy

Modos Operativos

Modo Mock (MOCK)

Modo Proxy (PROXY)

Modo Híbrido (HYBRID)

Ejemplo de Inicio Rápido

Funcionalidades Avanzadas

Soporte de Autenticación

Casos de Uso

🤖 Integración con Frameworks de IA

Integración con LangGraph

Pruebas Multi-Agente con CrewAI

Herramientas de Pruebas de IA con LangChain

🏗️ Arquitectura de Doble Puerto

Beneficios de la Arquitectura

Configuración de Puertos

Puntos de Acceso

📊 Funciones Empresariales

Cumplimiento y Registro de Auditoría

Analíticas Avanzadas

🔄 Flujos de Trabajo de Pruebas con Estado

Tipos de Contexto

Ejemplo: Pruebas de Comercio Electrónico con Estado

🚀 Ejecución de Servidores Mock Generados

Usando Docker Compose (Recomendado)

Usando Uvicorn Directamente

Acceso a Funciones Mejoradas

📈 Rendimiento y Escalabilidad

Métricas de Rendimiento

Funciones de Escalabilidad

🔒 Funciones de Seguridad

Seguridad Integrada

Pruebas de Seguridad

🔐 Integración SchemaPin - Verificación Criptográfica de Esquemas

Mejora de Seguridad Revolucionaria

Configuración de Inicio Rápido

Configuración de Producción

Beneficios de Seguridad

Protección contra MCP Rug Pull

Cumplimiento y Gobernanza

Ejemplos de Integración

Verificación Básica de Herramientas

Verificación por Lotes

Integración con MCP Proxy

`generate_mock_api`

`query_mock_logs`

`discover_mock_servers`

`manage_mock_data`

Modo Mock (`MOCK`)

Modo Proxy (`PROXY`)

Modo Híbrido (`HYBRID`)