Blog

Cómo Crear un Servidor MCP Rápido para Código Claude

Audrey Lopez

Audrey Lopez

12 June 2025

Cómo Crear un Servidor MCP Rápido para Código Claude

El Protocolo de Contexto del Modelo (MCP) revoluciona la forma en que los asistentes de IA interactúan con herramientas externas y fuentes de datos. Piensa en MCP como un puerto USB-C universal para aplicaciones de IA: proporciona una forma estandarizada de conectar Claude Code a prácticamente cualquier fuente de datos, API o herramienta que puedas imaginar. Esta guía completa te llevará a través de la construcción de tu propio servidor MCP desde cero, permitiendo que Claude Code acceda a funcionalidades personalizadas que extienden sus capacidades mucho más allá de sus características integradas.

Ya sea que quieras integrar bases de datos, APIs, sistemas de archivos o crear herramientas completamente personalizadas, MCP proporciona la base para una extensibilidad ilimitada. Al final de este tutorial, tendrás un servidor MCP funcionando y comprenderás cómo expandirlo para cualquier caso de uso.

💡
¿Quieres una excelente herramienta de Prueba de API que genere hermosa Documentación de API?

¿Quieres una plataforma integrada, Todo-en-Uno para que tu Equipo de Desarrolladores trabaje junto con máxima productividad?

¡Apidog cumple todas tus demandas, y reemplaza a Postman a un precio mucho más asequible!
botón

¿Qué es un Servidor MCP y Por Qué Todo el Mundo Habla de Él?

Qué Hace Diferente a MCP

MCP (Protocolo de Contexto del Modelo) es un protocolo abierto desarrollado por Anthropic que permite a los modelos de IA comunicarse con servidores externos a través de una interfaz estandarizada. A diferencia de las integraciones de API tradicionales donde codificas puntos finales específicos, MCP proporciona una forma estructurada para que los asistentes de IA descubran, comprendan y utilicen herramientas externas de forma dinámica.

La genialidad de MCP reside en su capacidad de descubrimiento. Cuando Claude Code se conecta a tu servidor MCP, aprende automáticamente qué herramientas están disponibles, cómo usarlas y qué parámetros aceptan. Esto significa que puedes añadir nueva funcionalidad sin necesidad de actualizar el propio Claude Code.

Arquitectura de MCP en Profundidad

El protocolo sigue una arquitectura cliente-servidor con roles claramente definidos:

Flujo de Comunicación Explicado

Cuando Claude Code necesita usar una herramienta externa, esto es lo que sucede:

  1. Fase de Descubrimiento: Claude Code consulta tu servidor para ver las herramientas disponibles
  2. Validación de Esquema: Tu servidor responde con definiciones de herramientas y esquemas de entrada
  3. Selección de Herramientas: Claude Code elige las herramientas apropiadas basándose en las solicitudes del usuario
  4. Fase de Ejecución: Claude Code envía llamadas a herramientas con parámetros validados
  5. Procesamiento de Resultados: Tu servidor procesa la solicitud y devuelve resultados estructurados

Este flujo asegura la seguridad de tipos, el manejo adecuado de errores y un comportamiento consistente en todas las integraciones MCP.

Prerrequisitos y Configuración del Entorno

Análisis de Requisitos del Sistema

Antes de construir tu servidor MCP, necesitas entender tu entorno de desarrollo y elegir las herramientas adecuadas. Los servidores MCP se pueden construir en múltiples lenguajes, pero Python y TypeScript son los más comúnmente soportados con herramientas extensas.

Para Desarrollo en Python:

Para Desarrollo en TypeScript/JavaScript:

Dependencias Principales:

Preparación del Entorno Paso a Paso

1. Instalar la CLI de Claude Code

La CLI de Claude Code es tu herramienta principal para gestionar servidores MCP. Instálala globalmente para asegurar el acceso desde cualquier directorio:

# Install Claude Code globally
npm install -g @anthropic-ai/claude-code

Por qué importa la instalación global: La instalación global asegura que el comando claude esté disponible en todo el sistema, evitando problemas relacionados con la ruta al registrar servidores MCP desde diferentes directorios.

2. Verificar la Instalación

Comprueba que Claude Code esté correctamente instalado y accesible:

# Verify installation and check version
claude --version

# Check available commands
claude --help

3. Configuración Crítica de Permisos por Primera Vez

Este paso es absolutamente esencial y a menudo se pasa por alto:

# Run initial setup with permissions bypass
claude --dangerously-skip-permissions

Qué hace este comando:

Por qué es necesario: Sin este paso, los servidores MCP no pueden establecer conexiones seguras con Claude Code, lo que lleva a fallos de autenticación y tiempos de espera de conexión.

Consideraciones de seguridad: La bandera --dangerously-skip-permissions es segura para entornos de desarrollo pero omite las solicitudes de seguridad normales. En entornos de producción, revisa cada solicitud de permiso cuidadosamente.

Configuración Crítica: Entendiendo los Ámbitos de MCP

Por Qué Importan los Ámbitos de Configuración

Uno de los errores más comunes al construir servidores MCP es la gestión incorrecta del ámbito de configuración. Comprender los ámbitos es crucial porque determinan dónde y cuándo tu servidor MCP está disponible para Claude Code. Muchos desarrolladores pasan horas depurando errores de "servidor no encontrado" que provienen de una mala configuración del ámbito.

Claude Code utiliza un sistema de configuración jerárquico diseñado para proporcionar flexibilidad manteniendo la seguridad. Cada ámbito cumple un propósito específico y tiene diferentes casos de uso.

Jerarquía de Ámbitos de Configuración Explicada

1. Ámbito de Proyecto (.mcp.json) - Máxima Prioridad

Ubicación: Directorio raíz del proyecto en un archivo .mcp.json

Propósito: Servidores MCP específicos del proyecto que solo deben estar disponibles cuando se trabaja en ese proyecto específico

Caso de uso: Conexiones a bases de datos específicas de un proyecto, linters específicos del proyecto o herramientas de construcción personalizadas

Cuándo es apropiado el ámbito de proyecto:

2. Ámbito de Usuario (-scope user) - Configuración Global

Ubicación: Configuración del directorio de inicio del usuario

Propósito: Servidores MCP disponibles globalmente en todos los proyectos y directorios

Caso de uso: Herramientas de propósito general como APIs del tiempo, herramientas de calculadora o utilidades del sistema

Por qué el ámbito de usuario suele ser preferido:

3. Ámbito Local (predeterminado) - Específico del Directorio

Ubicación: Contexto del directorio de trabajo actual

Propósito: Configuraciones rápidas y temporales de servidores MCP

Limitación: Solo funciona cuando ejecutas Claude Code desde ese directorio específico

Errores Comunes de Configuración

❌ Enfoque incorrecto (Ámbito local - funcionalidad limitada):

claude mcp add my-server python3 /path/to/server.py

Problema: Este servidor solo funciona cuando estás en el directorio exacto donde lo registraste.

✅ Enfoque correcto (Ámbito de usuario - acceso global):

claude mcp add --scope user my-server python3 /path/to/server.py

Beneficio: Este servidor funciona desde cualquier directorio en tu sistema.

Planificación Estratégica de Directorios

Estructura de Directorios Recomendada

Crea una estructura de directorios bien organizada para la mantenibilidad a largo plazo:

# Create permanent storage location
mkdir -p ~/.claude-mcp-servers/

# Organize by functionality
mkdir -p ~/.claude-mcp-servers/apis/
mkdir -p ~/.claude-mcp-servers/utilities/
mkdir -p ~/.claude-mcp-servers/development/

Beneficios de una Estructura Organizada

Mantenibilidad: Fácil de encontrar y actualizar servidores más tarde

Seguridad: Clara separación entre diferentes tipos de herramientas

Copia de seguridad: Simple hacer copia de seguridad de todos los servidores MCP haciendo copia de seguridad de un directorio

Compartir: Fácil compartir configuraciones de servidor con miembros del equipo

Guía de Solución de Problemas de Ámbito

Diagnosticando Problemas de Ámbito

Si tu servidor MCP no aparece, sigue esta secuencia de diagnóstico:

  1. Verifica la configuración del ámbito actual:
claude mcp list
  1. Verifica que no estás en un directorio con un ámbito de proyecto conflictivo:
ls .mcp.json
  1. Prueba desde diferentes directorios:
cd ~ && claude mcp list
cd /tmp && claude mcp list

Solucionando Problemas de Ámbito

Problema: El servidor solo funciona en un directorio

Solución: Elimina la configuración local y vuelve a añadirla con ámbito de usuario

# Remove problematic local configuration
claude mcp remove my-server

# Re-add with global user scope
claude mcp add --scope user my-server python3 /path/to/server.py

Construyendo Tu Primer Servidor MCP

Entendiendo el Proceso de Desarrollo

Construir un servidor MCP implica comprender tanto el protocolo MCP como los requisitos específicos de tu caso de uso. Comenzaremos con un servidor básico de "Hola Mundo" para entender los fundamentos, y luego construiremos sobre esa base.

El proceso de desarrollo sigue estas fases:

  1. Configuración de la Estructura del Servidor: Creando la estructura básica de archivos y el punto de entrada
  2. Implementación del Protocolo: Implementando los métodos MCP requeridos
  3. Definición de Herramientas: Definiendo qué herramientas proporciona tu servidor
  4. Registro y Pruebas: Añadiendo el servidor a Claude Code y verificando la funcionalidad
  5. Mejora y Producción: Añadiendo funcionalidad real y manejo de errores

Paso 1: Base y Estructura del Proyecto

Creando el Entorno de Desarrollo

Primero, establece un entorno de desarrollo adecuado para tu servidor MCP:

# Navigate to your MCP servers directory
cd ~/.claude-mcp-servers/

# Create a new server project
mkdir my-first-server
cd my-first-server

# Initialize the project structure
touch server.py
touch requirements.txt
touch .env

Por Qué Importa Esta Estructura

Desarrollo Organizado: Mantener cada servidor en su propio directorio previene conflictos y facilita el mantenimiento.

Aislamiento de Dependencias: Cada servidor puede tener sus propios requisitos sin afectar a otros.

Gestión de Configuración: Los archivos de entorno permiten una configuración segura sin codificar valores.

Entendiendo los Requisitos del Servidor MCP

Cada servidor MCP debe implementar tres métodos principales de JSON-RPC:

  1. initialize: Establece la conexión y declara las capacidades del servidor
  2. tools/list: Devuelve las herramientas disponibles y sus esquemas
  3. tools/call: Ejecuta herramientas específicas con los parámetros proporcionados

Paso 2: Implementando el Framework Principal del Servidor

Crea un archivo llamado server.py con la plantilla fundamental del servidor MCP:

#!/usr/bin/env python3
"""
Custom MCP Server for Claude Code Integration
"""

import json
import sys
import os
from typing import Dict, Any, Optional

# Ensure unbuffered output for proper MCP communication
sys.stdout = os.fdopen(sys.stdout.fileno(), 'w', 1)
sys.stderr = os.fdopen(sys.stderr.fileno(), 'w', 1)

def send_response(response: Dict[str, Any]):
    """Send a JSON-RPC response to Claude Code"""
    print(json.dumps(response), flush=True)

def handle_initialize(request_id: Any) -> Dict[str, Any]:
    """Handle MCP initialization handshake"""
    return {
        "jsonrpc": "2.0",
        "id": request_id,
        "result": {
            "protocolVersion": "2024-11-05",
            "capabilities": {
                "tools": {}
            },
            "serverInfo": {
                "name": "my-custom-server",
                "version": "1.0.0"
            }
        }
    }

def handle_tools_list(request_id: Any) -> Dict[str, Any]:
    """List available tools for Claude Code"""
    tools = [
        {
            "name": "hello_world",
            "description": "A simple demonstration tool",
            "inputSchema": {
                "type": "object",
                "properties": {
                    "name": {
                        "type": "string",
                        "description": "Name to greet"
                    }
                },
                "required": ["name"]
            }
        }
    ]

    return {
        "jsonrpc": "2.0",
        "id": request_id,
        "result": {
            "tools": tools
        }
    }

def handle_tool_call(request_id: Any, params: Dict[str, Any]) -> Dict[str, Any]:
    """Execute tool calls from Claude Code"""
    tool_name = params.get("name")
    arguments = params.get("arguments", {})

    try:
        if tool_name == "hello_world":
            name = arguments.get("name", "World")
            result = f"Hello, {name}! Your MCP server is working perfectly."
        else:
            raise ValueError(f"Unknown tool: {tool_name}")

        return {
            "jsonrpc": "2.0",
            "id": request_id,
            "result": {
                "content": [
                    {
                        "type": "text",
                        "text": result
                    }
                ]
            }
        }
    except Exception as e:
        return {
            "jsonrpc": "2.0",
            "id": request_id,
            "error": {
                "code": -32603,
                "message": str(e)
            }
        }

def main():
    """Main server loop handling JSON-RPC communication"""
    while True:
        try:
            line = sys.stdin.readline()
            if not line:
                break

            request = json.loads(line.strip())
            method = request.get("method")
            request_id = request.get("id")
            params = request.get("params", {})

            if method == "initialize":
                response = handle_initialize(request_id)
            elif method == "tools/list":
                response = handle_tools_list(request_id)
            elif method == "tools/call":
                response = handle_tool_call(request_id, params)
            else:
                response = {
                    "jsonrpc": "2.0",
                    "id": request_id,
                    "error": {
                        "code": -32601,
                        "message": f"Method not found: {method}"
                    }
                }

            send_response(response)

        except json.JSONDecodeError:
            continue
        except EOFError:
            break
        except Exception as e:
            if 'request_id' in locals():
                send_response({
                    "jsonrpc": "2.0",
                    "id": request_id,
                    "error": {
                        "code": -32603,
                        "message": f"Internal error: {str(e)}"
                    }
                })

if __name__ == "__main__":
    main()

Explicación de la Arquitectura del Código

Configuración de Entrada/Salida: Las primeras líneas configuran la E/S sin búfer, lo cual es crítico para la comunicación MCP. La salida con búfer puede causar retrasos en la entrega de mensajes que rompen el protocolo.

Manejo de JSON-RPC: El bucle principal lee las solicitudes JSON-RPC desde stdin y escribe las respuestas en stdout. Esto sigue la especificación MCP para la comunicación de servidores locales.

Estrategia de Manejo de Errores: El código implementa múltiples capas de manejo de errores:

Cumplimiento del Protocolo: Cada respuesta incluye el campo jsonrpc: "2.0" requerido y el ID de solicitud para una correlación adecuada.

Paso 3: Preparación y Prueba del Servidor

Haciendo el Servidor Ejecutable

# Make the server executable
chmod +x server.py

Por qué importan los permisos de ejecución: Los servidores MCP son lanzados como subprocesos por Claude Code. Sin permisos de ejecución, el lanzamiento fallará con errores de permisos crípticos.

Prueba Manual del Protocolo

Antes de registrarte con Claude Code, prueba la implementación del protocolo del servidor:

# Test the initialize handshake
echo '{"jsonrpc":"2.0","id":1,"method":"initialize","params":{}}' | python3 server.py

Qué esperar: Deberías ver una respuesta JSON que contenga la versión del protocolo y las capacidades. Si ves mensajes de error o ninguna salida, verifica tu instalación de Python y la sintaxis del script.

Pasos de Validación

Realiza estas comprobaciones de validación antes de continuar:

  1. Comprobación de Sintaxis: python3 -m py_compile server.py
  2. Prueba de Importación: python3 -c "import json, sys, os"
  3. Prueba de Ejecución: Verifica que la prueba manual del protocolo funcione

Paso 4: Registro con Claude Code

Añadiendo Tu Servidor

Registra tu servidor usando el ámbito adecuado y rutas absolutas:

# Register with global user scope for universal access
claude mcp add --scope user my-first-server python3 ~/.claude-mcp-servers/my-first-server/server.py

Detalles críticos:

Verificación y Solución de Problemas

# Verify registration
claude mcp list

# Check for any connection issues
claude mcp get my-first-server

Problemas comunes de registro:

Ejemplo Avanzado: Integración con API del Tiempo

Más Allá de "Hola Mundo"

Ahora que comprendes la estructura básica del servidor MCP, construyamos un servidor más práctico que demuestre patrones de integración del mundo real. Este servidor de API del tiempo te enseñará:

Planificando Tu Integración de API

Antes de escribir código, considera estos aspectos de integración:

Selección de API: Usaremos la API de OpenWeatherMap por su simplicidad y nivel gratuito

Flujo de Datos: Solicitud del usuario → Validación de parámetros → Llamada a API → Formato de respuesta → Respuesta de Claude

Escenarios de Error: Fallos de red, claves de API inválidas, respuestas mal formadas, limitación de velocidad

Seguridad: Claves de API almacenadas en variables de entorno, saneamiento de entrada

Estrategia de Implementación

Construyamos este servidor incrementalmente, implementando cada parte con manejo completo de errores:

#!/usr/bin/env python3
import json
import sys
import os
import requests
from typing import Dict, Any

# Configuration - use environment variables for security
WEATHER_API_KEY = os.environ.get("OPENWEATHER_API_KEY", "your-api-key-here")

def get_weather(city: str) -> str:
    """Fetch current weather data for a specified city"""
    try:
        url = "<http://api.openweathermap.org/data/2.5/weather>"
        params = {
            "q": city,
            "appid": WEATHER_API_KEY,
            "units": "metric"
        }
        response = requests.get(url, params=params, timeout=10)
        data = response.json()

        if response.status_code == 200:
            temp = data["main"]["temp"]
            desc = data["weather"][0]["description"]
            humidity = data["main"]["humidity"]
            return f"Weather in {city}: {temp}°C, {desc.title()}, Humidity: {humidity}%"
        else:
            return f"Error fetching weather: {data.get('message', 'Unknown error')}"
    except requests.RequestException as e:
        return f"Network error: {str(e)}"
    except Exception as e:
        return f"Error processing weather data: {str(e)}"

def handle_tools_list(request_id: Any) -> Dict[str, Any]:
    """Enhanced tools list with weather functionality"""
    tools = [
        {
            "name": "get_weather",
            "description": "Get current weather conditions for any city worldwide",
            "inputSchema": {
                "type": "object",
                "properties": {
                    "city": {
                        "type": "string",
                        "description": "City name (e.g., 'London', 'Tokyo', 'New York')"
                    }
                },
                "required": ["city"]
            }
        }
    ]

    return {
        "jsonrpc": "2.0",
        "id": request_id,
        "result": {
            "tools": tools
        }
    }

def handle_tool_call(request_id: Any, params: Dict[str, Any]) -> Dict[str, Any]:
    """Enhanced tool execution with weather functionality"""
    tool_name = params.get("name")
    arguments = params.get("arguments", {})

    try:
        if tool_name == "get_weather":
            city = arguments.get("city")
            if not city:
                raise ValueError("City name is required")
            result = get_weather(city)
        else:
            raise ValueError(f"Unknown tool: {tool_name}")

        return {
            "jsonrpc": "2.0",
            "id": request_id,
            "result": {
                "content": [
                    {
                        "type": "text",
                        "text": result
                    }
                ]
            }
        }
    except Exception as e:
        return {
            "jsonrpc": "2.0",
            "id": request_id,
            "error": {
                "code": -32603,
                "message": str(e)
            }
        }

# Include the same main() function and other handlers from the basic example

Características Avanzadas Explicadas

Seguridad con Variables de Entorno: La clave de API se carga desde variables de entorno, nunca codificada directamente. Esto previene la exposición accidental en el control de versiones.

Manejo Robusto de Errores: La función get_weather() maneja múltiples escenarios de error:

Esquema de Herramienta Mejorado: El esquema de la herramienta del tiempo incluye descripciones detalladas y ejemplos, ayudando a Claude Code a comprender cómo usar la herramienta de manera efectiva.

Paso 5: Gestión Profesional de Dependencias y Configuración

Creando un Archivo de Requisitos Adecuado

requests>=2.28.0
python-dotenv>=1.0.0

Estrategia de fijación de versiones: Usar requisitos de versión mínima (>=) asegura la compatibilidad mientras permite actualizaciones de seguridad. Para servidores de producción, considera la fijación de versión exacta.

Configuración Segura del Entorno

Crea un archivo .env para la gestión de la configuración:

# Weather API configuration
OPENWEATHER_API_KEY=your_actual_api_key_here

# Server configuration
MCP_LOG_LEVEL=INFO
MCP_DEBUG=false

# Optional: Rate limiting
MCP_MAX_REQUESTS_PER_MINUTE=60

Mejores prácticas de seguridad:

Instalación y Aislamiento de Dependencias

# Create virtual environment for isolation
python3 -m venv mcp-env
source mcp-env/bin/activate  # On Windows: mcp-env\\\\Scripts\\\\activate

# Install dependencies
pip install -r requirements.txt

# Verify installation
python3 -c "import requests; print('Dependencies installed successfully')"

Por qué importan los entornos virtuales: El aislamiento previene conflictos de dependencias entre diferentes servidores MCP y tu instalación de Python del sistema.

Probando y Depurando Tu Servidor MCP

Estrategia de Pruebas Integral

Probar servidores MCP requiere un enfoque multicapa porque estás lidiando tanto con el cumplimiento del protocolo como con la corrección funcional. Una estrategia de pruebas sistemática previene que los problemas lleguen a producción y facilita mucho la depuración.

Pirámide de Pruebas para Servidores MCP

  1. Pruebas Unitarias: Pruebas de funciones individuales
  2. Pruebas de Protocolo: Verificación del cumplimiento de JSON-RPC
  3. Pruebas de Integración: Pruebas de interacción con Claude Code
  4. Pruebas de Extremo a Extremo: Validación completa del flujo de trabajo

Capa 1: Prueba Manual del Protocolo

Probando los Métodos Principales de MCP

Antes de cualquier integración, verifica que tu servidor implemente el protocolo MCP correctamente:

# Test initialization handshake
echo '{"jsonrpc":"2.0","id":1,"method":"initialize","params":{}}' | python3 server.py

Estructura de respuesta esperada:

{
  "jsonrpc": "2.0",
  "id": 1,
  "result": {
    "protocolVersion": "2024-11-05",
    "capabilities": {"tools": {}},
    "serverInfo": {"name": "your-server", "version": "1.0.0"}
  }
}

Probando el Descubrimiento de Herramientas

# Test tools list endpoint
echo '{"jsonrpc":"2.0","id":2,"method":"tools/list","params":{}}' | python3 server.py

Lista de verificación de validación:

Probando la Ejecución de Herramientas

# Test actual tool functionality
echo '{"jsonrpc":"2.0","id":3,"method":"tools/call","params":{"name":"get_weather","arguments":{"city":"London"}}}' | python3 server.py

Qué verificar:

Capa 2: Framework de Pruebas Automatizadas

Creando Scripts de Prueba

Crea un archivo llamado test_server.py para pruebas automatizadas:

#!/usr/bin/env python3
import json
import subprocess
import sys

def test_mcp_method(method, params=None):
    """Test a specific MCP method"""
    request = {
        "jsonrpc": "2.0",
        "id": 1,
        "method": method,
        "params": params or {}
    }

    try:
        result = subprocess.run(
            [sys.executable, "server.py"],
            input=json.dumps(request),
            capture_output=True,
            text=True,
            timeout=10
        )
        return json.loads(result.stdout.strip())
    except Exception as e:
        return {"error": str(e)}

# Test suite
tests = [
    ("initialize", None),
    ("tools/list", None),
    ("tools/call", {"name": "hello_world", "arguments": {"name": "Test"}})
]

for method, params in tests:
    response = test_mcp_method(method, params)
    print(f"Testing {method}: {'✓ PASS' if 'result' in response else '✗ FAIL'}")

Capa 3: Pruebas de Integración con Claude Code

Registro y Verificación del Servidor

# Register your server
claude mcp add --scope user test-server python3 /full/path/to/server.py

# Verify registration
claude mcp list | grep test-server

# Check server health
claude mcp get test-server

Pruebas de Integración en Vivo

# Start Claude Code in test mode
claude

# In Claude Code, test tool discovery
/mcp

# Test tool execution
mcp__test-server__hello_world name:"Integration Test"

Patrón de nombres de herramientas: Claude Code prefija las herramientas con mcp__<nombre-servidor>__<nombre-herramienta> para evitar conflictos de nombres.

Técnicas Avanzadas de Depuración

Habilitando el Registro de Depuración

Añade registro completo a tu servidor:

import logging
import sys

# Configure logging to stderr (won't interfere with JSON-RPC)
logging.basicConfig(
    level=logging.DEBUG,
    stream=sys.stderr,
    format='%(asctime)s - %(levelname)s - %(message)s'
)

logger = logging.getLogger(__name__)

def handle_tool_call(request_id, params):
    logger.debug(f"Received tool call: {params}")
    # ... your tool logic
    logger.debug(f"Tool execution completed successfully")

Análisis de Registros del Servidor MCP

Claude Code mantiene registros para cada servidor MCP:

# View recent logs (macOS)
tail -f ~/Library/Logs/Claude/mcp-server-*.log

# View recent logs (Linux)
tail -f ~/.config/claude/logs/mcp-server-*.log

# Search for errors
grep -i error ~/Library/Logs/Claude/mcp-server-*.log

Patrones Comunes de Depuración

Problema: El servidor arranca pero las herramientas no aparecen

Diagnóstico: Verifica el formato de respuesta de tools/list

Solución: Valida el cumplimiento del esquema JSON

Problema: Las llamadas a herramientas fallan silenciosamente

Diagnóstico: Verifica el manejo de errores en tools/call

Solución: Añade manejo completo

Practica el diseño de API en Apidog

Descubre una forma más fácil de construir y usar APIs

Registrarse gratisDescargar