Claude Desktop + Modelo Local Ajustado: Guía Completa de Configuración

Claude Desktop es un asistente de IA poderoso. Tu modelo ajustado está especializado en tu dominio. Puedes conectarlos vía MCP (Model Context Protocol) para obtener la interfaz de Claude con la experiencia de dominio de tu modelo — y pagar cero costos de API por la inferencia especializada.

Esta guía recorre la configuración completa: despliegue de Ollama, servidor MCP, configuración de Claude Desktop y pruebas.

Requisitos Previos

• Claude Desktop instalado (descarga en claude.ai/download)
• Un modelo GGUF ajustado de Ertas
• Node.js 18+ (para el servidor MCP)
• 8GB+ de RAM en tu máquina (para ejecutar Ollama con un modelo 7B)

Paso 1: Instalar y Configurar Ollama

# macOS / Linux
curl -fsSL https://ollama.ai/install.sh | sh

# Windows: download installer from ollama.ai

Importa tu modelo GGUF ajustado:

# Create a Modelfile — this defines how Ollama will run your model
cat > Modelfile << 'EOF'
FROM /path/to/your-model.gguf

# System prompt baked into the model
SYSTEM """
You are a specialized AI assistant for [your domain]. [Add a brief description of what your model does and how it should behave.]
"""

# Optional: tune generation parameters
PARAMETER temperature 0.3
PARAMETER num_ctx 4096
EOF

# Create the model with a name you will use to call it
ollama create my-domain-model -f Modelfile

Verifica que el modelo cargue correctamente:

ollama run my-domain-model "Test prompt — describe what you do"

Deberías ver una respuesta de tu modelo ajustado. Si devuelve un error sobre cargar el GGUF, verifica la ruta del archivo en tu Modelfile.

Paso 2: Instalar el SDK de MCP

Crea un directorio de proyecto para tu servidor MCP:

mkdir claude-domain-mcp
cd claude-domain-mcp
npm init -y
npm install @modelcontextprotocol/sdk

Paso 3: Escribir el Servidor MCP

Crea server.mjs:

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_URL = 'http://localhost:11434/api/chat';
const MODEL = 'my-domain-model'; // Must match what you named it in Ollama

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

// Define tools that Claude can use
server.setRequestHandler(ListToolsRequestSchema, async () => {
  return {
    tools: [
      {
        name: 'ask_domain_model',
        description:
          'Use this for [describe your domain task precisely — e.g., "generating real estate listing descriptions", "classifying support tickets", "writing on-brand copy for ClientX"]. This model has specialized knowledge of [domain specifics].',
        inputSchema: {
          type: 'object',
          properties: {
            request: {
              type: 'string',
              description: 'The specific task or question for the domain model',
            },
            context: {
              type: 'string',
              description: 'Relevant context such as property details, product specs, customer info, etc.',
            },
          },
          required: ['request'],
        },
      },
    ],
  };
});

// Handle tool invocations from Claude
server.setRequestHandler(CallToolRequestSchema, async (request) => {
  if (request.params.name !== 'ask_domain_model') {
    throw new Error(`Unknown tool: ${request.params.name}`);
  }

  const { request: userRequest, context } = request.params.arguments;

  const userMessage = context
    ? `${context}\n\n${userRequest}`
    : userRequest;

  let response;
  try {
    const res = await fetch(OLLAMA_URL, {
      method: 'POST',
      headers: { 'Content-Type': 'application/json' },
      body: JSON.stringify({
        model: MODEL,
        messages: [{ role: 'user', content: userMessage }],
        stream: false,
      }),
    });

    if (!res.ok) {
      throw new Error(`Ollama returned ${res.status}: ${await res.text()}`);
    }

    const data = await res.json();
    response = data.message?.content ?? 'No response from model';
  } catch (err) {
    return {
      content: [
        {
          type: 'text',
          text: `Error calling domain model: ${err.message}. Is Ollama running?`,
        },
      ],
      isError: true,
    };
  }

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

const transport = new StdioServerTransport();
await server.connect(transport);

Prueba que el servidor funcione de forma independiente:

echo '{"jsonrpc":"2.0","method":"tools/list","id":1}' | node server.mjs

Deberías ver una respuesta JSON listando tus herramientas.

Paso 4: Configurar Claude Desktop

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

{
  "mcpServers": {
    "domain-assistant": {
      "command": "node",
      "args": ["/absolute/path/to/claude-domain-mcp/server.mjs"],
      "env": {
        "NODE_ENV": "production"
      }
    }
  }
}

Importante: Usa la ruta absoluta a server.mjs. Las rutas relativas no funcionan de manera confiable.

Cierra Claude Desktop completamente (Command+Q / clic derecho en la barra de tareas → Salir en Windows) y reláncelo.

Paso 5: Verificar la Conexión

En Claude Desktop, busca el ícono de herramientas (ícono de martillo en la barra de entrada). Haz clic para ver las herramientas disponibles. Deberías ver ask_domain_model listado bajo "domain-assistant."

Prueba con un prompt que debería activar tu herramienta:

"Usando el modelo de dominio, genera [tu tipo de salida esperado] para [entrada de prueba]."

Claude debería llamar a tu herramienta y devolver la respuesta. Si no llama a la herramienta, intenta ser más explícito: "Por favor usa la herramienta de asistente de dominio para..."

Solución de Problemas

La herramienta no aparece en Claude Desktop:

• Verifica que el JSON del archivo de configuración sea válido (sin comas finales, sintaxis correcta)
• Verifica que la ruta a server.mjs sea absoluta y correcta
• Revisa los logs de Claude Desktop: macOS ~/Library/Logs/Claude/, Windows %APPDATA%\Claude\logs\

La herramienta se llama pero devuelve error:

• Ejecuta ollama serve manualmente en una terminal y confirma que ollama run my-domain-model "test" funciona
• Verifica que el nombre del modelo en server.mjs coincida exactamente con el nombre que le diste en Ollama
• Verifica que Ollama esté escuchando en el puerto 11434: curl http://localhost:11434/api/tags

El modelo da respuestas incorrectas o genéricas:

• Verifica que el archivo GGUF se haya cargado correctamente (es la versión ajustada, no el modelo base)
• Verifica que el system prompt de tu Modelfile sea apropiado
• Prueba diferentes configuraciones de temperatura en el Modelfile

---

Lectura Adicional

• MCP + Fine-Tuned Local Model — La visión general de la arquitectura
• MCP Server Zero API Costs — El caso de costo para esta configuración
• OpenAI-Compatible Local API — Usando la interfaz de API compatible con OpenAI de Ollama
• Cursor MCP Fine-Tuned Model — El mismo patrón en Cursor IDE