MockLoop

Uma plataforma de teste de API nativa de IA para gerar cenários, executar testes e analisar resultados.

Documentação

NOTA: Implementamos totalmente o SchemaPin para ajudar a combater cópias questionáveis deste projeto no Github e em outros lugares. Certifique-se de validar que você está usando releases deste repositório e pode usar o SchemaPin para validar nossos esquemas de ferramentas: https://mockloop.com/.well-known/schemapin.json

MockLoop MCP - Plataforma de Testes Nativa de IA

A primeira plataforma de testes de API nativa de IA do mundo alimentada pelo Model Context Protocol (MCP). O MockLoop MCP revoluciona os testes de API com geração abrangente de cenários orientada por IA, execução automatizada de testes e capacidades de análise inteligente.

🚀 Capacidades Revolucionárias: 5 Prompts de IA • 15 Recursos de Cenário • 16 Ferramentas de Teste • 10 Ferramentas de Contexto • 4 Ferramentas Principais • Integração MCP Completa

📚 Documentação: https://docs.mockloop.com
📦 Pacote PyPI: https://pypi.org/project/mockloop-mcp/
🐙 Repositório GitHub: https://github.com/mockloop/mockloop-mcp

🌟 O Que Torna o MockLoop MCP Revolucionário?

O MockLoop MCP representa uma mudança de paradigma nos testes de API, introduzindo a primeira arquitetura de testes nativa de IA do mundo que combina:

🤖 Geração de Testes Orientada por IA: 5 prompts MCP especializados para criação inteligente de cenários
📦 Pacotes de Cenários da Comunidade: 15 recursos de teste curados com arquitetura comunitária
⚡ Execução Automatizada de Testes: 30 ferramentas MCP abrangentes para fluxos de trabalho completos de teste (16 de teste + 10 de contexto + 4 principais)
🔄 Testes com Estado: Gerenciamento avançado de contexto com GlobalContext e AgentContext
📊 Conformidade Empresarial: Registro de auditoria completo e rastreamento de conformidade regulatória
🏗️ Arquitetura de Porta Dupla: Elimina conflitos de caminho /admin com portas separadas de API simulada e administração

🎯 Arquitetura Central Nativa de IA

Registro de Auditoria MCP

Conformidade e rastreamento regulatório de nível empresarial

Trilhas de auditoria completas de solicitação/resposta
Monitoramento de conformidade regulatória
Métricas de desempenho e análises
Registro de eventos de segurança

Prompts MCP (5 Capacidades Orientadas por IA)

Geração inteligente de cenários alimentada por IA

analyze_openapi_for_testing - Análise abrangente de API para estratégias de teste
generate_scenario_config - Configuração dinâmica de cenários de teste
optimize_scenario_for_load - Otimização de testes de carga
generate_error_scenarios - Simulação de condições de erro
generate_security_test_scenarios - Teste de vulnerabilidades de segurança

Recursos MCP (15 Pacotes de Cenários)

Cenários de teste orientados pela comunidade com arquitetura avançada

Cenários de Teste de Carga: Simulação de tráfego de alto volume
Pacotes de Simulação de Erros: Teste abrangente de condições de erro
Suítes de Teste de Segurança: Cenários de avaliação de vulnerabilidades
Benchmarks de Desempenho: Teste de desempenho padronizado
Pacotes de Teste de Integração: Cenários de teste entre serviços
Arquitetura Comunitária: Compartilhamento colaborativo e validação de cenários

Ferramentas MCP (16 Ferramentas de Teste Automatizado)

Capacidades completas de execução automatizada de testes

Gerenciamento de Cenários (4 ferramentas)

validate_scenario_config - Validação e verificação de cenários
deploy_scenario - Implantação automatizada de cenários
switch_scenario - Alternância dinâmica de cenários
list_active_scenarios - Monitoramento ativo de cenários

Execução de Testes (4 ferramentas)

execute_test_plan - Execução abrangente de plano de teste
run_test_iteration - Gerenciamento de iteração de teste individual
run_load_test - Execução de teste de carga
run_security_test - Automação de teste de segurança

Análise e Relatórios (4 ferramentas)

analyze_test_results - Análise inteligente de resultados de teste
generate_test_report - Relatórios abrangentes
compare_test_runs - Comparação e tendências de execução de teste
get_performance_metrics - Coleta de métricas de desempenho

Gerenciamento de Fluxo de Trabalho (4 ferramentas)

create_test_session - Inicialização de sessão de teste
end_test_session - Limpeza e finalização de sessão
schedule_test_suite - Agendamento automatizado de testes
monitor_test_progress - Monitoramento de progresso em tempo real

Gerenciamento de Contexto MCP (10 Ferramentas de Fluxo de Trabalho com Estado)

Gerenciamento avançado de estado para fluxos de trabalho de teste complexos

Criação e Gerenciamento de Contexto

create_test_session_context - Gerenciamento de estado de sessão de teste
create_workflow_context - Orquestração de fluxo de trabalho complexo
create_agent_context - Gerenciamento de estado de agente de IA

Gerenciamento de Dados

get_context_data - Recuperação de dados de contexto
update_context_data - Atualizações dinâmicas de contexto
list_contexts_by_type - Descoberta e listagem de contexto

Snapshot e Recuperação

create_context_snapshot - Criação de snapshot de estado
restore_context_snapshot - Capacidades de reversão de estado

Contexto Global

get_global_context_data - Compartilhamento de dados entre sessões
update_global_context_data - Gerenciamento de estado global

🚀 Início Rápido

Comece com a plataforma de testes nativa de IA mais avançada do 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

📋 Pré-requisitos

Python 3.10+
Gerenciador de pacotes Pip
Docker e Docker Compose (para servidores mock em contêineres)
Um cliente compatível com MCP (Cline, Claude Desktop, etc.)

🔧 Instalação

Opção 1: Instalar a partir do 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

Opção 2: Instalação de Desenvolvimento

# 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]"

⚙️ Configuração

Configuração do Cliente MCP

Cline (Extensão do VS Code)

Adicione ao seu arquivo de configurações MCP do Cline:

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

Claude Desktop

Adicione à sua configuração do Claude Desktop:

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

Instalações em Ambiente Virtual

Para instalações em ambiente virtual, use o caminho completo do Python:

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

🛠️ Ferramentas MCP Disponíveis

Geração Principal de Mock

`generate_mock_api`

Gere servidores mock FastAPI sofisticados com arquitetura de porta dupla.

Parâmetros:

spec_url_or_path (string, obrigatório): URL da especificação da API ou caminho de arquivo local
output_dir_name (string, opcional): Nome do diretório de saída
auth_enabled (booleano, opcional): Habilitar middleware de autenticação (padrão: true)
webhooks_enabled (booleano, opcional): Habilitar suporte a webhook (padrão: true)
admin_ui_enabled (booleano, opcional): Habilitar interface de administração (padrão: true)
storage_enabled (booleano, opcional): Habilitar funcionalidade de armazenamento (padrão: true)

Arquitetura Revolucionária de Porta Dupla:

Porta da API Simulada: Atende seus endpoints de API (padrão: 8000)
Porta da Interface de Administração: Interface de administração separada (padrão: 8001)
Resolução de Conflitos: Elimina conflitos de caminho /admin em especificações OpenAPI
Segurança Aprimorada: Controle de acesso e isolamento baseados em porta

Análises Avançadas

`query_mock_logs`

Consulte e analise logs de solicitações com insights alimentados por IA.

Parâmetros:

server_url (string, obrigatório): URL do servidor mock
limit (inteiro, opcional): Máximo de logs a retornar (padrão: 100)
offset (inteiro, opcional): Deslocamento de paginação (padrão: 0)
method (string, opcional): Filtrar por método HTTP
path_pattern (string, opcional): Padrão regex para filtragem de caminho
time_from (string, opcional): Filtro de hora de início (formato ISO)
time_to (string, opcional): Filtro de hora de término (formato ISO)
include_admin (booleano, opcional): Incluir solicitações de administração (padrão: false)
analyze (booleano, opcional): Realizar análise de IA (padrão: true)

Análise Alimentada por IA:

Métricas de desempenho (tempos de resposta P95/P99)
Análise e categorização de taxa de erro
Detecção de padrões de tráfego
Recomendações automatizadas de depuração
Correlação e rastreamento de sessão

`discover_mock_servers`

Descoberta inteligente de servidores com suporte a arquitetura de porta dupla.

Parâmetros:

ports (array, opcional): Portas para escanear (padrão: portas comuns)
check_health (booleano, opcional): Realizar verificações de saúde (padrão: true)
include_generated (booleano, opcional): Incluir mocks gerados (padrão: true)

Descoberta Avançada:

Detecção automática de arquitetura (porta única vs porta dupla)
Monitoramento de status de saúde
Correlação e correspondência de servidores
Análise de uso de portas

`manage_mock_data`

Gerenciamento dinâmico de respostas sem reiniciar o servidor.

Parâmetros:

server_url (string, obrigatório): URL do servidor mock
operation (string, obrigatório): Tipo de operação ("update_response", "create_scenario", "switch_scenario", "list_scenarios")
endpoint_path (string, opcional): Caminho do endpoint da API
response_data (objeto, opcional): Novos dados de resposta
scenario_name (string, opcional): Nome do cenário
scenario_config (objeto, opcional): Configuração do cenário

Capacidades Dinâmicas:

Atualizações de resposta em tempo real
Testes baseados em cenários
Gerenciamento de configuração em tempo de execução
Modificações sem tempo de inatividade

🌐 Funcionalidade de Proxy MCP

O MockLoop MCP inclui capacidades revolucionárias de proxy que permitem alternância perfeita entre ambientes de API mock e ao vivo. Este recurso poderoso transforma seu fluxo de trabalho de teste ao fornecer:

Capacidades Principais do Proxy

🔄 Alternância de Modo Perfeita: Transição entre modos mock, proxy e híbrido sem alterações de código
🎯 Roteamento Inteligente: Roteamento inteligente de solicitações com base em regras e condições configuráveis
🔐 Autenticação Universal: Suporte para API Key, Bearer Token, Basic Auth e OAuth2
📊 Comparação de Respostas: Comparação automatizada entre respostas de API mock e ao vivo
⚡ Alternância sem Tempo de Inatividade: Alterne modos dinamicamente sem interrupção de serviço

Modos Operacionais

Modo Mock (`MOCK`)

Todas as solicitações tratadas por respostas mock geradas
Ambiente de teste previsível e consistente
Ideal para desenvolvimento inicial e testes isolados
Sem dependências externas ou chamadas de rede

Modo Proxy (`PROXY`)

Todas as solicitações encaminhadas para endpoints de API ao vivo
Dados em tempo real e respostas autênticas
Capacidades completas de teste de integração
Operação dependente de rede com credenciais ao vivo

Modo Híbrido (`HYBRID`)

Roteamento inteligente entre mock e proxy com base em regras
Alternância condicional com base em padrões de solicitação, cabeçalhos ou parâmetros
Migração gradual de ambientes mock para ambientes ao vivo
Testes A/B e proxy seletivo de endpoints

Exemplo de Início 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
        }
    ]
)

Recursos Avançados

🔍 Validação de Respostas: Compare respostas mock vs ao vivo para consistência
📈 Monitoramento de Desempenho: Acompanhe tempos de resposta e throughput entre modos
🛡️ Tratamento de Erros: Mecanismos de fallback graciosos e políticas de repetição
🎛️ Configuração Dinâmica: Alternância de modo em tempo de execução e atualizações de regras
📋 Registro de Auditoria: Rastreamento completo de solicitações/respostas em todos os modos

Suporte a Autenticação

O sistema de proxy suporta esquemas abrangentes de autenticação:

API Key: Autenticação baseada em cabeçalho, parâmetro de consulta ou cookie
Bearer Token: Suporte a tokens OAuth2 e JWT
Basic Auth: Combinações de nome de usuário/senha
OAuth2: Fluxo OAuth2 completo com atualização de token
Custom: Manipuladores de autenticação extensíveis para esquemas proprietários

Casos de Uso

Fluxo de Desenvolvimento: Comece com mocks, introduza gradualmente APIs reais
Testes de Integração: Valide contra serviços reais mantendo o isolamento de testes
Testes de Performance: Compare características de desempenho entre mock e API real
Validação de Staging: Garanta que as respostas mock correspondam ao comportamento da API de produção
Implantações Híbridas: Roteie operações críticas para APIs reais, outras para mocks

📚 Guia Completo: Para configuração detalhada, exemplos e melhores práticas, consulte o Guia do Proxy MCP.

🤖 Integração com Frameworks de IA

O MockLoop MCP fornece integração nativa com frameworks de IA populares:

Integração com 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()

Testes Multi-Agente com 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()

Ferramentas de Teste de IA com 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"
})

🏗️ Arquitetura de Porta Dupla

O MockLoop MCP introduz uma arquitetura de porta dupla revolucionária que elimina conflitos comuns e aumenta a segurança:

Benefícios da Arquitetura

🔒 Segurança Aprimorada: Separação completa entre API mockada e funcionalidade administrativa
⚡ Zero Conflitos: Elimina conflitos de caminho /admin em especificações OpenAPI
📊 Análises Limpas: Chamadas administrativas não aparecem nas métricas da API mockada
🔄 Escalonamento Independente: Escale a API mockada e os serviços administrativos separadamente
🛡️ Controle de Acesso Baseado em Porta: Segurança aprimorada através de isolamento de rede

Configuração de Portas

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

Pontos de Acesso

API Mockada: http://localhost:8000 - Seus endpoints de API
UI Administrativa: http://localhost:8001 - Interface de gerenciamento
Documentação da API: http://localhost:8000/docs - UI Swagger interativa
Verificação de Saúde: http://localhost:8000/health - Status do servidor

📊 Recursos Empresariais

Conformidade e Registro de Auditoria

O MockLoop MCP fornece recursos de conformidade de nível empresarial:

Trilhas de Auditoria Completas: Cada requisição/resposta registrada com metadados
Conformidade Regulatória: Suporte a GDPR, SOX, HIPAA
Métricas de Performance: Tempos de resposta P95/P99, taxas de erro
Monitoramento de Segurança: Detecção e análise de ameaças
Rastreamento de Sessão: Correlação e análise entre requisições

Análises Avançadas

Insights Impulsionados por IA: Análise inteligente e recomendações
Detecção de Padrões de Tráfego: Detecção automatizada de anomalias
Otimização de Performance: Recomendações de desempenho orientadas por IA
Análise de Erros: Categorização e resolução inteligente de erros
Análise de Tendências: Tendências históricas de desempenho e uso

🔄 Fluxos de Teste com Estado

O MockLoop MCP suporta fluxos de teste complexos e com estado através de gerenciamento avançado de contexto:

Tipos de Contexto

Contexto de Sessão de Teste: Mantém estado entre execuções de teste
Contexto de Fluxo de Trabalho: Orquestração complexa de testes em múltiplas etapas
Contexto de Agente: Gerenciamento e coordenação de estado de agentes de IA
Contexto Global: Compartilhamento e persistência de dados entre sessões

Exemplo: Teste de E-commerce com 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
)

🚀 Executando Servidores Mock Gerados

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 Diretamente

# Install dependencies
pip install -r requirements_mock.txt

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

Acesso a Recursos Aprimorados

UI Administrativa: http://localhost:8001 - Interface de gerenciamento aprimorada
Documentação da API: http://localhost:8000/docs - UI Swagger interativa
Verificação de Saúde: http://localhost:8000/health - Status e métricas do servidor
Análise de Logs: http://localhost:8001/api/logs/search - Consulta avançada de logs
Métricas de Performance: http://localhost:8001/api/logs/analyze - Insights impulsionados por IA
Gerenciamento de Cenários: http://localhost:8001/api/mock-data/scenarios - Testes dinâmicos

📈 Performance e Escalabilidade

O MockLoop MCP é projetado para performance em escala empresarial:

Métricas de Performance

Tempos de Resposta: Rastreamento de percentis P50, P95, P99
Throughput: Monitoramento de requisições por segundo
Taxas de Erro: Análise abrangente de erros
Uso de Recursos: Monitoramento de memória, CPU e rede
Concorrência: Suporte a testes de carga multi-usuário

Recursos de Escalabilidade

Escalonamento Horizontal: Suporte a implantação multi-instância
Balanceamento de Carga: Capacidades integradas de balanceamento de carga
Cache: Cache inteligente de respostas
Otimização de Banco de Dados: Suporte eficiente a SQLite e PostgreSQL
Orquestração de Contêineres: Pronto para Kubernetes e Docker Swarm

🔒 Recursos de Segurança

Segurança Integrada

Middleware de Autenticação: Mecanismos de autenticação configuráveis
Limitação de Taxa: Previne abuso e ataques DoS
Validação de Entrada: Validação abrangente de requisições
Cabeçalhos de Segurança: CORS, CSP e cabeçalhos de segurança
Registro de Auditoria: Registro completo de eventos de segurança

Testes de Segurança

Avaliação de Vulnerabilidades: Testes de segurança impulsionados por IA
Testes de Penetração: Geração automatizada de cenários de segurança
Verificação de Conformidade: Verificação de conformidade com padrões de segurança
Modelagem de Ameaças: Análise de ameaças orientada por IA
Relatórios de Segurança: Análises abrangentes de segurança

🔐 Integração SchemaPin - Verificação Criptográfica de Esquemas

O MockLoop MCP agora inclui integração SchemaPin - o primeiro sistema de verificação criptográfica de esquemas do setor para ferramentas MCP, prevenindo ataques "MCP Rug Pull" através de verificação de assinatura ECDSA e fixação de chaves Trust-On-First-Use (TOFU).

Aprimoramento Revolucionário de Segurança

A integração SchemaPin transforma o MockLoop MCP na plataforma de testes MCP mais segura, fornecendo:

🔐 Verificação Criptográfica: Assinaturas ECDSA P-256 garantem a integridade do esquema
🔑 Fixação de Chaves TOFU: Descoberta automática de chaves e fixação para domínios confiáveis
📋 Aplicação de Políticas: Políticas de segurança configuráveis (modos enforce/warn/log)
📊 Auditoria Abrangente: Logs de verificação completos para conformidade
🔄 Fallback Gracioso: Funciona com ou sem a biblioteca SchemaPin
🏗️ Arquitetura Híbrida: Integração perfeita com sistemas MockLoop existentes

Configuração de Início 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}")

Configuração de Produção

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

Benefícios de Segurança

Proteção contra MCP Rug Pull

O SchemaPin impede que atores maliciosos modifiquem esquemas de ferramentas sem detecção:

Assinaturas Criptográficas: Cada esquema de ferramenta é assinado criptograficamente
Fixação de Chaves: O modelo TOFU previne ataques man-in-the-middle
Trilhas de Auditoria: Logs de verificação completos para análise de segurança
Aplicação de Políticas: Respostas configuráveis a falhas de verificação

Conformidade e Governança

Conformidade Regulatória: Logs de auditoria suportam requisitos GDPR, SOX, HIPAA
Segurança Empresarial: Integração com frameworks de segurança existentes
Gerenciamento de Riscos: Políticas de segurança configuráveis para diferentes ambientes
Detecção de Ameaças: Detecção automatizada de tentativas de adulteração de esquemas

Exemplos de Integração

Verificação Básica de Ferramenta

# 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"
)

Verificação em Lote

# 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"}
])

Integração com Proxy MCP

# 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

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

Modo Warn

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

Modo Log

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

Gerenciamento de Chaves

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

Descoberta de Chaves

O SchemaPin descobre automaticamente chaves públicas via 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"
}

Auditoria e Conformidade

Registro Abrangente

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}%")

Relatórios de Conformidade

# 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")

Documentação e Exemplos

📚 Guia de Integração Completo: docs/guides/schemapin-integration.md
🔧 Exemplo de Uso Básico: examples/schemapin/basic_usage.py
⚡ Padrões Avançados: examples/schemapin/advanced_usage.py
🏗️ Documentação de Arquitetura: SchemaPin_MockLoop_Integration_Architecture.md
🧪 Cobertura de Testes: 56 testes abrangentes (42 unitários + 14 de integração)

Migração para Usuários Existentes

A integração SchemaPin é completamente compatível com versões anteriores:

Configuração Opt-in: O SchemaPin está desabilitado por padrão
Sem Mudanças Quebradas: Ferramentas existentes continuam funcionando sem alterações
Implantação Gradual: Comece com o modo log, progrida para warn, depois enforce
Zero Downtime: Habilite a verificação sem interrupção de serviço

# 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 na Performance

O SchemaPin é projetado para impacto mínimo na performance:

Tempo de Verificação: ~5-15ms por ferramenta (resultados em cache)
Uso de Memória: <10MB de memória adicional
Overhead de Rede: Descoberta de chaves apenas no primeiro uso
Tamanho do Banco de Dados: ~1KB por chave fixada

Casos de Uso

Equipes de Desenvolvimento

Desenvolvimento Seguro: Verifique esquemas de ferramentas durante o desenvolvimento
Revisão de Código: Garanta a integridade do esquema em pull requests
Testes: Valide o comportamento da ferramenta com esquemas verificados

Segurança Empresarial

Prevenção de Ameaças: Bloqueie modificações maliciosas de esquemas
Conformidade: Atenda requisitos regulatórios com trilhas de auditoria
Gerenciamento de Riscos: Políticas de segurança configuráveis
Resposta a Incidentes: Logs detalhados para análise de segurança

DevOps e CI/CD

Segurança de Pipeline: Verifique esquemas em pipelines de implantação
Promoção de Ambientes: Garanta consistência de esquemas entre ambientes
Monitoramento: Monitoramento contínuo de verificação
Automação: Aplicação automatizada de políticas de segurança

##️ Desenvolvimento Futuro

Próximos Recursos 🚧

Capacidades Aprimoradas de IA

Modelos de ML Avançados: Treinamento de modelos personalizados para testes de API
Análise Preditiva: Previsão de falhas impulsionada por IA
Geração Inteligente de Testes: Cenários de teste auto-melhoráveis
Testes em Linguagem Natural: Descrições de teste em inglês simples

Suporte Estendido a Protocolos

Suporte a GraphQL: Testes nativos de API GraphQL
Integração gRPC: Suporte a testes de protocol buffers
Testes WebSocket: Testes de comunicação em tempo real
Testes Orientados a Eventos: Testes de API assíncronos e baseados em eventos

Integração Empresarial

Integração CI/CD: Integração nativa com pipelines
Plataformas de Monitoramento: Integração com Datadog, New Relic, Prometheus
Provedores de Identidade: Integração com SSO e autenticação empresarial
Frameworks de Conformidade: Suporte estendido a conformidade regulatória

🤝 Contribuindo

Aceitamos contribuições para o MockLoop MCP! Consulte nossas Diretrizes de Contribuição para detalhes.

Configuração de Desenvolvimento

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

Comunidade

Repositório GitHub: mockloop/mockloop-mcp
Issues e Relatórios de Bugs: GitHub Issues
Solicitações de Recursos: GitHub Issues
Documentação: docs.mockloop.com

📄 Licença

O MockLoop MCP é licenciado sob a Licença MIT.

🎉 Comece Hoje!

Pronto para revolucionar seus testes de API com a primeira plataforma de testes nativa de IA do mundo?

pip install mockloop-mcp

Junte-se à revolução de testes nativa de IA e experimente o futuro dos testes de API com o MockLoop MCP!

🚀 Comece Agora →

MockLoop

Documentação

MockLoop MCP - Plataforma de Testes Nativa de IA

🌟 O Que Torna o MockLoop MCP Revolucionário?

🎯 Arquitetura Central Nativa de IA

Registro de Auditoria MCP

Prompts MCP (5 Capacidades Orientadas por IA)

Recursos MCP (15 Pacotes de Cenários)

Ferramentas MCP (16 Ferramentas de Teste Automatizado)

Gerenciamento de Cenários (4 ferramentas)

Execução de Testes (4 ferramentas)

Análise e Relatórios (4 ferramentas)

Gerenciamento de Fluxo de Trabalho (4 ferramentas)

Gerenciamento de Contexto MCP (10 Ferramentas de Fluxo de Trabalho com Estado)

Criação e Gerenciamento de Contexto

Gerenciamento de Dados

Snapshot e Recuperação

Contexto Global

🚀 Início Rápido

📋 Pré-requisitos

🔧 Instalação

Opção 1: Instalar a partir do PyPI (Recomendado)

Opção 2: Instalação de Desenvolvimento

⚙️ Configuração

Configuração do Cliente MCP

Cline (Extensão do VS Code)

Claude Desktop

Instalações em Ambiente Virtual

🛠️ Ferramentas MCP Disponíveis

Geração Principal de Mock

generate_mock_api

Análises Avançadas

query_mock_logs

discover_mock_servers

manage_mock_data

🌐 Funcionalidade de Proxy MCP

Capacidades Principais do Proxy

Modos Operacionais

Modo Mock (MOCK)

Modo Proxy (PROXY)

Modo Híbrido (HYBRID)

Exemplo de Início Rápido

Recursos Avançados

Suporte a Autenticação

Casos de Uso

🤖 Integração com Frameworks de IA

Integração com LangGraph

Testes Multi-Agente com CrewAI

Ferramentas de Teste de IA com LangChain

🏗️ Arquitetura de Porta Dupla

Benefícios da Arquitetura

Configuração de Portas

Pontos de Acesso

📊 Recursos Empresariais

Conformidade e Registro de Auditoria

Análises Avançadas

🔄 Fluxos de Teste com Estado

Tipos de Contexto

Exemplo: Teste de E-commerce com Estado

🚀 Executando Servidores Mock Gerados

Usando Docker Compose (Recomendado)

Usando Uvicorn Diretamente

Acesso a Recursos Aprimorados

📈 Performance e Escalabilidade

Métricas de Performance

Recursos de Escalabilidade

🔒 Recursos de Segurança

Segurança Integrada

Testes de Segurança

🔐 Integração SchemaPin - Verificação Criptográfica de Esquemas

Aprimoramento Revolucionário de Segurança

Configuração de Início Rápido

Configuração de Produção

Benefícios de Segurança

Proteção contra MCP Rug Pull

Conformidade e Governança

Exemplos de Integração

Verificação Básica de Ferramenta

Verificação em Lote

Integração com Proxy MCP

`generate_mock_api`

`query_mock_logs`

`discover_mock_servers`

`manage_mock_data`

Modo Mock (`MOCK`)

Modo Proxy (`PROXY`)

Modo Híbrido (`HYBRID`)