{"id":204,"date":"2026-11-08T07:22:36","date_gmt":"2026-11-08T03:22:36","guid":{"rendered":"https:\/\/demensdeum.com\/blog\/2026\/11\/08\/opencode-mcp-deepseek\/"},"modified":"2026-11-08T07:22:36","modified_gmt":"2026-11-08T03:22:36","slug":"opencode-mcp-deepseek","status":"publish","type":"post","link":"https:\/\/demensdeum.com\/blog\/es\/2026\/11\/08\/opencode-mcp-deepseek\/","title":{"rendered":"MCP en OpenCode en DeepSeek: c\u00f3mo conectar herramientas externas"},"content":{"rendered":"<p>MCP (Model Context Protocol) es un protocolo abierto que describe c\u00f3mo conectar herramientas externas y fuentes de datos al modelo de lenguaje: un sistema de archivos, documentaci\u00f3n, rastreador de tareas, rastreador de errores o su propio servicio. En lugar de integrar cada herramienta en el agente, se configura un servidor MCP independiente y el agente se comunica con \u00e9l seg\u00fan el esquema est\u00e1ndar.<\/p>\n<p>OpenCode admite MCP desde el primer momento: tanto servidores locales, que se inician mediante un proceso secundario, como servidores remotos, accesibles a trav\u00e9s de HTTP. Un punto importante es que toda la capa MCP se implementa en el lado del propio OpenCode y no en el lado del proveedor del modelo. Por lo tanto, DeepSeek recibe las herramientas MCP como funciones normales en la solicitud y no necesita saber nada sobre el protocolo en s\u00ed.<\/p>\n<p>En esta publicaci\u00f3n, veremos c\u00f3mo agregar un servidor local y remoto, c\u00f3mo obtener la autorizaci\u00f3n, c\u00f3mo no ahogarme en tokens y qu\u00e9 considerar al trabajar con modelos de DeepSeek.<\/p>\n<h2>Lo que necesitas<\/h2>\n<p>Para trabajar necesitas tres cosas:<\/p>\n<ul>\n<li><b>OpenCode instalado.<\/b> Si el agente a\u00fan no est\u00e1 configurado, analic\u00e9 el procedimiento para instalar y conectar DeepSeek en una nota separada.<\/li>\n<li><b>Node.js y npx.<\/b> Necesario para servidores MCP locales, que se distribuyen como paquetes npm.<\/li>\n<li><b>Claves de acceso.<\/b> S\u00f3lo para aquellos servidores remotos que requieran autorizaci\u00f3n. Los servidores p\u00fablicos como Context7 funcionan sin clave, pero con l\u00edmites m\u00e1s bajos.<\/li>\n<\/ul>\n<h2>C\u00f3mo funciona<\/h2>\n<p>Los servidores se describen en la configuraci\u00f3n de OpenCode en el bloque <b>mcp<\/b>. Cada servidor tiene un nombre \u00fanico por el cual se le puede mencionar en una solicitud. Las herramientas del servidor se registran con este prefijo de nombre, por lo que no hay conflictos entre diferentes servidores.<\/p>\n<p>Despu\u00e9s de conectarse, las herramientas MCP est\u00e1n disponibles para los modelos junto con las integradas: leer archivos, editar c\u00f3digo y ejecutar comandos. Desde el punto de vista de DeepSeek, estas son funciones ordinarias que un agente puede llamar, raz\u00f3n por la cual el paquete funciona sin ning\u00fan soporte MCP en el lado de la API del modelo.<\/p>\n<h2>Servidor local<\/h2>\n<p>La forma m\u00e1s sencilla de familiarizarse con el mecanismo es el servidor de prueba <b>@modelcontextprotocol\/server-everything<\/b>. Agregu\u00e9moslo al archivo <b>opencode.json<\/b> en la ra\u00edz del proyecto:<\/p>\n<div class=\"hcb_wrap\">\n<pre class=\"prism undefined-numbers lang-unknown\" data-lang=\"unknown\"><code>{\n  \"$schema\": \"https:\/\/opencode.ai\/config.json\",\n  \"mcp\": {\n    \"mcp_everything\": {\n      \"type\": \"local\",\n      \"command\": [\"npx\", \"-y\", \"@modelcontextprotocol\/server-everything\"]\n    }\n  }\n}\n<\/code><\/pre>\n<\/div>\n<p>El campo <b>comando<\/b> es el comando de inicio del servidor y sus argumentos en forma de matriz. Despu\u00e9s de reiniciar OpenCode, las herramientas aparecer\u00e1n en la sesi\u00f3n y se podr\u00e1n solicitar expl\u00edcitamente:<\/p>\n<div class=\"hcb_wrap\">\n<pre class=\"prism undefined-numbers lang-unknown\" data-lang=\"unknown\"><code>\u0438\u0441\u043f\u043e\u043b\u044c\u0437\u0443\u0439 \u0438\u043d\u0441\u0442\u0440\u0443\u043c\u0435\u043d\u0442 mcp_everything, \u0447\u0442\u043e\u0431\u044b \u0441\u043b\u043e\u0436\u0438\u0442\u044c 3 \u0438 4\n<\/code><\/pre>\n<\/div>\n<p>El servidor local tiene varios campos m\u00e1s \u00fatiles. <b>entorno<\/b> establece las variables de entorno del proceso, <b>cwd<\/b> &#8211; el directorio de trabajo, <b>timeout<\/b> &#8211; tiempo de espera de solicitud en milisegundos y <b>enabled<\/b> le permite deshabilitar temporalmente el servidor sin eliminarlo de la configuraci\u00f3n.<\/p>\n<h2>Servidor remoto<\/h2>\n<p>Los servidores remotos son m\u00e1s convenientes: no es necesario ejecutar nada localmente y se puede acceder a ellos a trav\u00e9s de una URL. Un buen ejemplo es Context7, que busca documentaci\u00f3n de biblioteca actualizada. Se conecta sin llave:<\/p>\n<div class=\"hcb_wrap\">\n<pre class=\"prism undefined-numbers lang-unknown\" data-lang=\"unknown\"><code>{\n  \"$schema\": \"https:\/\/opencode.ai\/config.json\",\n  \"mcp\": {\n    \"context7\": {\n      \"type\": \"remote\",\n      \"url\": \"https:\/\/mcp.context7.com\/mcp\"\n    }\n  }\n}\n<\/code><\/pre>\n<\/div>\n<p>Si tienes una cuenta gratuita de Context7, la clave es aumentar los l\u00edmites. Los encabezados se transmiten a trav\u00e9s del bloque <b>headers<\/b> y es conveniente mantener la clave en una variable de entorno:<\/p>\n<div class=\"hcb_wrap\">\n<pre class=\"prism undefined-numbers lang-unknown\" data-lang=\"unknown\"><code>{\n  \"$schema\": \"https:\/\/opencode.ai\/config.json\",\n  \"mcp\": {\n    \"context7\": {\n      \"type\": \"remote\",\n      \"url\": \"https:\/\/mcp.context7.com\/mcp\",\n      \"headers\": {\n        \"CONTEXT7_API_KEY\": \"{env:CONTEXT7_API_KEY}\"\n      }\n    }\n  }\n}\n<\/code><\/pre>\n<\/div>\n<p>La construcci\u00f3n <b>{env:NAME}<\/b> sustituye el valor de la variable de entorno al cargar la configuraci\u00f3n, por lo que la clave no termina en el repositorio. Antes de iniciar el agente, se debe exportar la variable en la terminal.<\/p>\n<p>Otro servidor p\u00fablico \u00fatil es Grep de Vercel; busque ejemplos de c\u00f3digo en GitHub:<\/p>\n<div class=\"hcb_wrap\">\n<pre class=\"prism undefined-numbers lang-unknown\" data-lang=\"unknown\"><code>{\n  \"$schema\": \"https:\/\/opencode.ai\/config.json\",\n  \"mcp\": {\n    \"gh_grep\": {\n      \"type\": \"remote\",\n      \"url\": \"https:\/\/mcp.grep.app\"\n    }\n  }\n}\n<\/code><\/pre>\n<\/div>\n<h2>Autorizaci\u00f3n v\u00eda OAuth<\/h2>\n<p>Algunos servidores remotos requieren OAuth. OpenCode puede atravesar este escenario por s\u00ed mismo: detecta la respuesta 401, activa la autorizaci\u00f3n y guarda los tokens. Para Sentry, simplemente especifique el servidor:<\/p>\n<div class=\"hcb_wrap\">\n<pre class=\"prism undefined-numbers lang-unknown\" data-lang=\"unknown\"><code>{\n  \"$schema\": \"https:\/\/opencode.ai\/config.json\",\n  \"mcp\": {\n    \"sentry\": {\n      \"type\": \"remote\",\n      \"url\": \"https:\/\/mcp.sentry.dev\/mcp\",\n      \"oauth\": {}\n    }\n  }\n}\n<\/code><\/pre>\n<\/div>\n<p>Despu\u00e9s de esto, la autorizaci\u00f3n se puede iniciar manualmente; se abrir\u00e1 el navegador:<\/p>\n<div class=\"hcb_wrap\">\n<pre class=\"prism undefined-numbers lang-unknown\" data-lang=\"unknown\"><code>opencode mcp auth sentry\n<\/code><\/pre>\n<\/div>\n<p>Los comandos de servicio tambi\u00e9n son \u00fatiles en el trabajo diario. La <b>lista de mcp de c\u00f3digo abierto<\/b> muestra los servidores y el estado de autorizaci\u00f3n, el <b>cierre de sesi\u00f3n de mcp de c\u00f3digo abierto<\/b> elimina los tokens almacenados y la <b>depuraci\u00f3n de mcp de c\u00f3digo abierto<\/b> verifica la conectividad de red y el descubrimiento de OAuth para un servidor espec\u00edfico. Los tokens se almacenan localmente en el archivo <b>~\/.local\/share\/opencode\/mcp-auth.json<\/b>.<\/p>\n<p>Si el servidor no utiliza OAuth, sino una clave API normal, la autorizaci\u00f3n autom\u00e1tica debe estar deshabilitada; de lo contrario, OpenCode intentar\u00e1 pasar OAuth donde no sea necesario:<\/p>\n<div class=\"hcb_wrap\">\n<pre class=\"prism undefined-numbers lang-unknown\" data-lang=\"unknown\"><code>{\n  \"$schema\": \"https:\/\/opencode.ai\/config.json\",\n  \"mcp\": {\n    \"my-api-key-server\": {\n      \"type\": \"remote\",\n      \"url\": \"https:\/\/mcp.example.com\/mcp\",\n      \"oauth\": false,\n      \"headers\": {\n        \"Authorization\": \"Bearer {env:MY_API_KEY}\"\n      }\n    }\n  }\n}\n<\/code><\/pre>\n<\/div>\n<h2>Gesti\u00f3n de herramientas<\/h2>\n<p>Las herramientas MCP consumen contexto: cada servidor agrega descripciones de sus funciones a la solicitud. Por lo tanto, es mejor mantener apagados los servidores que rara vez se necesitan. Esto se puede hacer globalmente a trav\u00e9s del bloque <b>herramientas<\/b>:<\/p>\n<div class=\"hcb_wrap\">\n<pre class=\"prism undefined-numbers lang-unknown\" data-lang=\"unknown\"><code>{\n  \"$schema\": \"https:\/\/opencode.ai\/config.json\",\n  \"mcp\": {\n    \"my-mcp-foo\": {\n      \"type\": \"local\",\n      \"command\": [\"npx\", \"-y\", \"my-mcp-command-foo\"]\n    },\n    \"my-mcp-bar\": {\n      \"type\": \"local\",\n      \"command\": [\"npx\", \"-y\", \"my-mcp-command-bar\"]\n    }\n  },\n  \"tools\": {\n    \"my-mcp*\": false\n  }\n}\n<\/code><\/pre>\n<\/div>\n<p>La plantilla <b>my-mcp*<\/b> deshabilita todas las herramientas cuyo nombre comienza con este prefijo. Si hay muchos servidores, tiene m\u00e1s sentido deshabilitarlos globalmente y habilitarlos localmente para un agente espec\u00edfico:<\/p>\n<div class=\"hcb_wrap\">\n<pre class=\"prism undefined-numbers lang-unknown\" data-lang=\"unknown\"><code>{\n  \"$schema\": \"https:\/\/opencode.ai\/config.json\",\n  \"mcp\": {\n    \"my-mcp\": {\n      \"type\": \"local\",\n      \"command\": [\"npx\", \"-y\", \"my-mcp-command\"],\n      \"enabled\": true\n    }\n  },\n  \"tools\": {\n    \"my-mcp*\": false\n  },\n  \"agent\": {\n    \"my-agent\": {\n      \"tools\": {\n        \"my-mcp*\": true\n      }\n    }\n  }\n}\n<\/code><\/pre>\n<\/div>\n<h2>Funciones de b\u00fasqueda profunda<\/h2>\n<p>La conexi\u00f3n con DeepSeek funciona porque los modelos admiten funciones de llamada y las herramientas MCP para ellos parecen funciones normales. DeepSeek en s\u00ed no conecta servidores MCP y no deber\u00eda hacerlo: la conexi\u00f3n la maneja OpenCode.<\/p>\n<p>A qu\u00e9 debes prestar atenci\u00f3n:<\/p>\n<ul>\n<li><b>Seleccionar un modelo.<\/b> Para ediciones peque\u00f1as y rutinarias, <b>deepseek-flash<\/b> es suficiente. Para tareas en las que necesitas mantener mucho contexto en tu cabeza y seleccionar cuidadosamente una herramienta, es mejor usar <b>deepseek-v4-pro<\/b>.<\/li>\n<li><b>Tama\u00f1o del contexto.<\/b> Los servidores pesados \u200b\u200bcomo GitHub MCP agregan muchos tokens y, junto con un proyecto grande, alcanzan f\u00e1cilmente el l\u00edmite. Act\u00edvelos solo mientras dure una tarea espec\u00edfica.<\/li>\n<p>Los esquemas de herramientas de <\/p>\n<li><b>costos<\/b> se env\u00edan con cada solicitud, por lo que cuantos m\u00e1s servidores se incluyan, m\u00e1s costosa ser\u00e1 cada iteraci\u00f3n. Pagas al proveedor directamente, por lo que los servidores adicionales se notan en tu factura.<\/li>\n<li><b>Consejos para el agente.<\/b> Es m\u00e1s seguro no confiar en el ingenio del modelo, sino nombrar directamente el servidor en la solicitud o escribir una regla en <b>AGENTS.md<\/b>.<\/li>\n<\/ul>\n<p>Un ejemplo de una regla para <b>AGENTS.md<\/b>, para que el propio agente acceda a la fuente requerida:<\/p>\n<div class=\"hcb_wrap\">\n<pre class=\"prism undefined-numbers lang-unknown\" data-lang=\"unknown\"><code>\u041a\u043e\u0433\u0434\u0430 \u043d\u0443\u0436\u043d\u043e \u043f\u043e\u0441\u043c\u043e\u0442\u0440\u0435\u0442\u044c \u0434\u043e\u043a\u0443\u043c\u0435\u043d\u0442\u0430\u0446\u0438\u044e \u0431\u0438\u0431\u043b\u0438\u043e\u0442\u0435\u043a\u0438, \u0438\u0441\u043f\u043e\u043b\u044c\u0437\u0443\u0439 \u0438\u043d\u0441\u0442\u0440\u0443\u043c\u0435\u043d\u0442\u044b context7.\n<\/code><\/pre>\n<\/div>\n<h2>Receta pr\u00e1ctica<\/h2>\n<p>Para el trabajo diario, suelen ser suficientes dos servidores: Context7 para la documentaci\u00f3n y un servidor estrecho para una tarea espec\u00edfica, por ejemplo, Sentry para analizar errores o Grep para buscar ejemplos de c\u00f3digo. Es mejor mantener el resto apagado y encenderlo seg\u00fan sea necesario.<\/p>\n<p>Mi procedimiento es el siguiente: agrego el servidor a <b>opencode.json<\/b>, reinicio OpenCode, verifico la lista a trav\u00e9s de <b>opencode mcp list<\/b> y luego hago una pregunta de prueba que menciona expl\u00edcitamente el servidor. Si no se llama a la herramienta, miro hacia la <b>depuraci\u00f3n de mcp de c\u00f3digo abierto<\/b> y el tiempo de espera; es posible que un servidor lento no tenga tiempo de responder en los 30 segundos asignados.<\/p>\n<h2>A qu\u00e9 prestar atenci\u00f3n<\/h2>\n<p>Un par de puntos pr\u00e1cticos. Los servidores MCP son c\u00f3digos confiables: el servidor local se ejecuta en su m\u00e1quina con sus derechos y usted env\u00eda los datos de la solicitud al remoto. Por lo tanto, la instalaci\u00f3n de servidores aleatorios desde Internet debe realizarse con la misma precauci\u00f3n que cualquier CLI de terceros.<\/p>\n<p>Mantenga las claves y los tokens en las variables de entorno y no se comprometa con el repositorio. OpenCode almacena tokens OAuth localmente, pero en una m\u00e1quina compartida tambi\u00e9n vale la pena considerar esto: <b>opencode mcp logoout<\/b> los elimina cuando ya no es necesario el acceso.<\/p>\n<p>Y una cosa m\u00e1s: no enciendas todo a la vez. MCP agrega herramientas al contexto, y el contexto es dinero y calidad de respuesta. Dos o tres servidores realmente necesarios funcionan mucho mejor que diez conectados por si acaso.<\/p>\n<h2>Enlaces<\/h2>\n<p><a href=\"https:\/\/opencode.ai\/docs\/mcp-servers\/\" rel=\"noopener\" target=\"_blank\">https:\/\/opencode.ai\/docs\/mcp-servers\/<\/a><br \/>\n<a href=\"https:\/\/opencode.ai\/docs\/config\/\" rel=\"noopener\" target=\"_blank\">https:\/\/opencode.ai\/docs\/config\/<\/a><br \/>\n<a href=\"https:\/\/modelcontextprotocol.io\/\" rel=\"noopener\" target=\"_blank\">https:\/\/modelcontextprotocol.io\/<\/a><br \/>\n<a href=\"https:\/\/github.com\/upstash\/context7\" rel=\"noopener\" target=\"_blank\">https:\/\/github.com\/upstash\/context7<\/a><br \/>\n<a href=\"https:\/\/mcp.sentry.dev\" rel=\"noopener\" target=\"_blank\">https:\/\/mcp.sentry.dev<\/a><br \/>\n<a href=\"https:\/\/mcp.grep.app\" rel=\"noopener\" target=\"_blank\">https:\/\/mcp.grep.app<\/a><br \/>\n<a href=\"https:\/\/github.com\/anomalyco\/opencode\" rel=\"noopener\" target=\"_blank\">https:\/\/github.com\/anomalyco\/opencode<\/a><\/p>\n<h2>Fuentes<\/h2>\n<p><a href=\"https:\/\/opencode.ai\/docs\/mcp-servers\/\" rel=\"noopener\" target=\"_blank\">https:\/\/opencode.ai\/docs\/mcp-servers\/<\/a><br \/>\n<a href=\"https:\/\/modelcontextprotocol.io\/\" rel=\"noopener\" target=\"_blank\">https:\/\/modelcontextprotocol.io\/<\/a><br \/>\n<a href=\"https:\/\/api-docs.deepseek.com\/\" rel=\"noopener\" target=\"_blank\">https:\/\/api-docs.deepseek.com\/<\/a><br \/>\n<a href=\"https:\/\/api-docs.deepseek.com\/quick_start\/agent_integrations\/opencode\" rel=\"noopener\" target=\"_blank\">https:\/\/api-docs.deepseek.com\/quick_start\/agent_integrations\/opencode<\/a><\/p>\n","protected":false},"excerpt":{"rendered":"<p>MCP (Model Context Protocol) es un protocolo abierto que describe c\u00f3mo conectar herramientas externas y fuentes de datos al modelo de lenguaje: un sistema de archivos, documentaci\u00f3n, rastreador de tareas, rastreador de errores o su propio servicio. En lugar de integrar cada herramienta en el agente, se configura un servidor MCP independiente y el agente [&hellip;]<\/p>\n","protected":false},"author":1,"featured_media":0,"comment_status":"open","ping_status":"open","sticky":false,"template":"","format":"standard","meta":{"footnotes":""},"categories":[8],"tags":[],"class_list":["post-204","post","type-post","status-publish","format-standard","hentry","category-notes"],"translation":{"provider":"WPGlobus","version":"3.0.6","language":"es","enabled_languages":["en","ru","zh","de","ja","fr","es","pt","hi"],"languages":{"en":{"title":true,"content":true,"excerpt":false},"ru":{"title":true,"content":true,"excerpt":false},"zh":{"title":true,"content":true,"excerpt":false},"de":{"title":true,"content":true,"excerpt":false},"ja":{"title":true,"content":true,"excerpt":false},"fr":{"title":true,"content":true,"excerpt":false},"es":{"title":true,"content":true,"excerpt":false},"pt":{"title":true,"content":true,"excerpt":false},"hi":{"title":true,"content":true,"excerpt":false}}},"_links":{"self":[{"href":"https:\/\/demensdeum.com\/blog\/es\/wp-json\/wp\/v2\/posts\/204","targetHints":{"allow":["GET"]}}],"collection":[{"href":"https:\/\/demensdeum.com\/blog\/es\/wp-json\/wp\/v2\/posts"}],"about":[{"href":"https:\/\/demensdeum.com\/blog\/es\/wp-json\/wp\/v2\/types\/post"}],"author":[{"embeddable":true,"href":"https:\/\/demensdeum.com\/blog\/es\/wp-json\/wp\/v2\/users\/1"}],"replies":[{"embeddable":true,"href":"https:\/\/demensdeum.com\/blog\/es\/wp-json\/wp\/v2\/comments?post=204"}],"version-history":[{"count":0,"href":"https:\/\/demensdeum.com\/blog\/es\/wp-json\/wp\/v2\/posts\/204\/revisions"}],"wp:attachment":[{"href":"https:\/\/demensdeum.com\/blog\/es\/wp-json\/wp\/v2\/media?parent=204"}],"wp:term":[{"taxonomy":"category","embeddable":true,"href":"https:\/\/demensdeum.com\/blog\/es\/wp-json\/wp\/v2\/categories?post=204"},{"taxonomy":"post_tag","embeddable":true,"href":"https:\/\/demensdeum.com\/blog\/es\/wp-json\/wp\/v2\/tags?post=204"}],"curies":[{"name":"wp","href":"https:\/\/api.w.org\/{rel}","templated":true}]}}