MCP + Modelo Local Fine-Tuned: Conecta Claude a Tu IA de Dominio Específico

Model Context Protocol (MCP) es el estándar abierto de Anthropic para conectar asistentes de IA con herramientas externas, fuentes de datos y servicios. Claude Desktop soporta MCP de forma nativa — y como los servidores MCP pueden ser cualquier servicio HTTP, puedes usarlo para conectar Claude a tu propio modelo fine-tuned alojado en Ollama.

El resultado: Claude maneja la interfaz de conversación y el razonamiento general, mientras tu modelo fine-tuned maneja las tareas de dominio específico para las que fue entrenado. Inferencia de dominio a cero costo, con la interfaz de Claude.

Qué Es Realmente MCP

MCP es un protocolo, no un producto. Define una forma estándar para que un asistente de IA (el cliente) descubra y llame capacidades de servidores externos (servidores MCP). Un servidor MCP expone:

• Herramientas — funciones que la IA puede llamar ("search_database", "classify_document", "generate_listing")
• Recursos — fuentes de datos que la IA puede leer ("customer_records", "product_catalog")
• Prompts — plantillas de prompts reutilizables que la IA puede referenciar

Claude Desktop lee un archivo de configuración MCP y se conecta a los servidores listados en él. Cuando le pides a Claude que haga algo, puede invocar las herramientas de esos servidores como parte de su respuesta.

Insight clave: Un servidor MCP es simplemente un servicio basado en HTTP o stdio. No hay nada especial en lo que se ejecuta dentro de él. Tu modelo fine-tuned, servido por Ollama, puede alimentar una herramienta MCP que Claude llama.

Arquitectura

User asks Claude Desktop: "Generate a listing for this property..."
        ↓
Claude Desktop recognizes this maps to the real_estate_tools MCP server
        ↓
Claude calls the generate_listing tool (via MCP)
        ↓
MCP server receives the request
        ↓
MCP server calls your Ollama API (fine-tuned listing model)
        ↓
Ollama returns the generated listing
        ↓
MCP server returns result to Claude
        ↓
Claude formats and presents the result to the user

Claude actúa como el orquestador y la interfaz de conversación. Tu modelo fine-tuned realiza la inferencia especializada de dominio.

Construir el Servidor MCP

Un servidor MCP se puede construir con el paquete npm @modelcontextprotocol/sdk o el paquete Python mcp.

Servidor MCP mínimo en Node.js que envuelve Ollama:

// mcp-server.js
import { Server } from '@modelcontextprotocol/sdk/server/index.js';
import { StdioServerTransport } from '@modelcontextprotocol/sdk/server/stdio.js';
import { CallToolRequestSchema, ListToolsRequestSchema } from '@modelcontextprotocol/sdk/types.js';

const OLLAMA_BASE = 'http://localhost:11434';
const MODEL_NAME = 'your-fine-tuned-model'; // Name you gave it in Ollama

const server = new Server(
  { name: 'domain-model-server', version: '1.0.0' },
  { capabilities: { tools: {} } }
);

// Declare the tools Claude can call
server.setRequestHandler(ListToolsRequestSchema, async () => ({
  tools: [
    {
      name: 'generate_domain_content',
      description: 'Generate domain-specific content using the fine-tuned model. Use this for [your use case description].',
      inputSchema: {
        type: 'object',
        properties: {
          prompt: {
            type: 'string',
            description: 'The specific request for the domain model'
          },
          context: {
            type: 'string',
            description: 'Additional context (property details, product info, etc.)'
          }
        },
        required: ['prompt']
      }
    }
  ]
}));

// Handle tool calls
server.setRequestHandler(CallToolRequestSchema, async (request) => {
  if (request.params.name === 'generate_domain_content') {
    const { prompt, context } = request.params.arguments;

    const fullPrompt = context
      ? `Context: ${context}\n\nRequest: ${prompt}`
      : prompt;

    const response = await fetch(`${OLLAMA_BASE}/api/chat`, {
      method: 'POST',
      headers: { 'Content-Type': 'application/json' },
      body: JSON.stringify({
        model: MODEL_NAME,
        messages: [{ role: 'user', content: fullPrompt }],
        stream: false
      })
    });

    const data = await response.json();
    const content = data.message.content;

    return {
      content: [{ type: 'text', text: content }]
    };
  }

  throw new Error(`Unknown tool: ${request.params.name}`);
});

// Start server over stdio (Claude Desktop connects this way)
const transport = new StdioServerTransport();
await server.connect(transport);

Configuración de Claude Desktop

Edita ~/Library/Application Support/Claude/claude_desktop_config.json (macOS) o %APPDATA%\Claude\claude_desktop_config.json (Windows):

{
  "mcpServers": {
    "domain-model": {
      "command": "node",
      "args": ["/path/to/your/mcp-server.js"],
      "env": {}
    }
  }
}

Reinicia Claude Desktop. Las herramientas de tu servidor MCP ahora están disponibles para Claude.

Probar la Conexión

En Claude Desktop, escribe un prompt que debería activar tu herramienta:

"Genera una descripción de listado para un bungalow craftsman de 3 habitaciones en Portland con cocina renovada y pisos originales de madera."

Claude debería invocar tu herramienta generate_domain_content y devolver la salida de tu modelo fine-tuned. Puedes observar la salida stdout del servidor MCP para ver la depuración y confirmar la conexión.

Ejemplos de Casos de Uso

Corretaje inmobiliario: Servidor MCP envolviendo un modelo de descripción de listados. El agente le pide a Claude "escribe un listado para [propiedad]", Claude llama la herramienta, el modelo fine-tuned genera la descripción acorde a la marca.

Soporte e-commerce: Servidor MCP envolviendo un modelo de resolución de soporte. El agente de soporte le pide a Claude "¿cómo debería responder a este ticket sobre [problema]?", Claude llama la herramienta, devuelve un borrador de resolución.

Agencia de contenido: Servidor MCP envolviendo un modelo de voz de marca. El copywriter le pide a Claude "escribe un post de LinkedIn sobre [tema] para [Marca]", Claude llama la herramienta específica de la marca.

El patrón general: Claude para la interfaz y el razonamiento, tu modelo fine-tuned para la tarea de dominio especializada.

---

Lectura Adicional

• Configuración de Claude Desktop con Modelo Local — Configuración paso a paso de Claude Desktop + Ollama
• Servidor MCP sin Costos de API — El caso de costos para MCP + modelos locales
• Cursor MCP con Modelo Fine-Tuned — El mismo patrón en Cursor IDE
• Herramientas MCP para Flujos de Trabajo de Clientes de Agencias — Entrega a agencias vía MCP