DeepCerebra Coder é un asistente de codificación axéntico. A diferenza dun copilot de autocompletado simple, planifica, escribe, refactoriza, executa comandos, chama a ferramentas e itera en todo o teu proxecto — contigo revisando e aprobando os cambios que propón.
| Edición | Mellor para | Acceso a ficheiros |
|---|---|---|
| Aplicación web | Instalación cero, traballa desde calquera máquina | Almacenamento confidencial no navegador (e repositorios Git) |
| Escritorio (Windows / Linux / macOS) | Desenvolvemento local-first, modelos locais | Sistema de ficheiros local directo |
| CLI e API | Scripting, CI/CD, automatización | Ficheiros locais / programático |
Esta guía céntrase na aplicación web en deepcerebra.ai; a aplicación de escritorio reflicte os mesmos paneis e fluxos de traballo.
Usa unha versión actual de Chrome, Edge ou Brave para unha experiencia completa — abrir un cartafol local depende da API de acceso ao sistema de ficheiros de Chromium. Firefox e Safari funcionan para o chat e para proxectos con respaldo Git, pero non poden abrir un cartafol local directamente.
/register?plan=basic (ou pro / ultimate), ou comezar agora e escoller un plan
máis tarde en Facturación.Despois de iniciar sesión, aterras no banco de traballo, que pon todos os paneis nunha soa pantalla:
Arrastra o divisor entre o editor e o chat para reequilibrar o deseño, e arrastra o divisor horizontal para redimensionar o terminal. A barra lateral esquerda tamén navega a Espazo de Traballo, Extensións, Chaves API, Facturación e Comentarios.
repo (clásico) ou un token de granulación fina con Contidos + Solicitude de extracción; para
GitLab usa o ámbito api. O teu token almacénase no servidor — só o contido dos ficheiros se extrae
ao navegador.propietario/nome (filtra a lista para atopar o teu), despois escolle unha
rama.dcc/a-miña-funcionalidade) para manter o teu
traballo illado da rama predeterminada.O historial de chat está vinculado ao proxecto aberto. Cambiar de cartafol inicia automaticamente unha nova sesión e carga as sesións anteriores dese cartafol, reabrindo a máis recente para que poidas retomar onde o deixaches.
Os cartafoles que DeepCerebra usa internamente — .deepcerebra, .sessions — aparecen na árbore
pero están colapsados por defecto para que non enchan o teu código fonte.
Describe o que queres en linguaxe sinxela — fai unha pregunta, solicita unha funcionalidade ou sinala un erro. Sé específico sobre ficheiros, frameworks e restricións para obter o mellor resultado. Anexa ficheiros relevantes arrastrándoos ao cadro de texto.
As respostas organízanse como en Cursor: o razoamento do axente sepárase do entregable. Cada bloque de resposta ten unha icona de copiar na súa esquina superior dereita para que poidas copiar un informe rematado, documento ou un comando que debes executar.
lxml en lugar de html.parser") para sacar o axente dun
bucle.@deepcerebra, e os prefixos como [deep] solicitan un razoamento máis profundo.Escolle un modo no selector de modo xunto ao cadro de texto. Cada un axusta canto planifica o axente e con que liberdade edita:
| Modo | Que fai | Usar cando… |
|---|---|---|
| Axente | Planifica e edita no teu proxecto de forma autónoma | Queres que o asistente implemente un cambio de principio a fin |
| Preguntar | Responde preguntas sobre o teu código sen editar | Queres comprender a base de código |
| Plan | Elabora unha estratexia antes de calquera edición | A tarefa é grande ou ten compromisos que resolver primeiro |
| Editar | Realiza edicións enfocadas no contexto actual | Queres un cambio pequeno e dirixido |
Cando o axente propón cambios nos ficheiros, aparece un panel de Cambios Propostos enriba da entrada do chat, listando cada ficheiro tocado con contas de liñas engadidas (+) e eliminadas (−).
aplicado (e · disco cando se escriben nun cartafol real).Activa o terminal debaixo do editor para executar compilacións, probas e scripts. Coa túa autorización, o axente pode executar comandos e ler a súa saída para verificar o seu traballo; os comandos de longa duración transmiten a saída para que poidas observar o progreso. Pecha o terminal desde a súa cabeceira cando non o necesites.
Para obxectivos máis grandes, usa o modo Plan (ou pídelle ao axente que planifique primeiro). O planificador escanea o teu proxecto, descompón o obxectivo en tarefas conscientes das dependencias e asigna cada unha ao especialista axeitado (arquitecto, programador, probador, documentación).
Abre o selector de modelos xunto ao cadro de texto. As opcións agrúpanse como:
En Automático, DeepCerebra usa un enrutamento adaptativo por niveis: as tarefas sinxelas van a un modelo rápido e económico, mentres que o traballo complexo ou con moita planificación (por exemplo, o modo Plan) diríxese a un modelo máis potente. Isto equilibra o custo e a calidade automaticamente, polo que raramente necesitarás escoller manualmente.
Podes enrutar as solicitudes a través da túa propia conta de provedor en lugar do uso medido da plataforma.
ANTHROPIC_API_KEY,
GOOGLE_API_KEY, OPENAI_API_KEY).Os modelos da plataforma (DeepCerebra) non necesitan chave. Elimina unha chave en calquera momento con Eliminar.
O DCC Bridge conecta o teu propio ordenador coa aplicación web a través dun pequeno
conector dcc-bridge, desbloqueando dúas capacidades á vez:
O conector marca saída a través dun WebSocket autenticado — non se necesitan portos de entrada, e funciona detrás de NAT e firewalls. Funciona en Windows, macOS e Linux (Python 3.10+).
dcc_brg_…)
e o comando do conector listo para pegar — o token móstrase exactamente unha vez.pip install git+https://github.com/mohammadkhair7/DeepCerebra-connector
# then run the command copied from the pairing card, e.g.:
python -m dcc_bridge --gateway wss://deepcerebra.ai --token dcc_brg_xxxxxwss://deepcerebra.ai ou wss://deepcerebra.io) — a tarxeta de emparellamento preenche o
correcto. Os dous sitios son despregamentos separados con contas e tokens separados.1234) cun modelo cargado.Por defecto, os comandos confínanse a un cartafol de espazo de traballo dedicado (~/DeepCerebra). Para traballar nos
teus cartafoles de proxecto reais coas túas CLIs preconfiguradas, concédelles explicitamente ao iniciar o conector:
# grant one or more real folders (repeatable)
python -m dcc_bridge --gateway wss://deepcerebra.ai --token dcc_brg_xxxxx --host-dir "F:\MyProjects"
# or the whole machine (prints a warning; prefer --host-dir)
python -m dcc_bridge ... --allow-any-dirDespois abre o panel Terminal, fai clic no menú despregable Obxectivo de execución (icona do portátil), escolle O meu ordenador e selecciona un directorio de traballo. Tanto os teus comandos escritos como os comandos de compilación/proba do axente executaranse na túa máquina.
--no-exec fai que un
dispositivo sexa só de inferencia (modelos GPU, sen comandos).Cun proxecto con respaldo Git aberto, aparece unha barra de ramas no Explorador que mostra a túa rama actual e dúas accións:
main). Debes estar nunha rama de traballo, non na rama predeterminada.Se o webhook de push está activado, o Explorador actualízase automaticamente cando os compañeiros de equipo fan push, mantendo a todos sincronizados — a base para o desenvolvemento colaborativo en equipo a través de DeepCerebra.
Estende o axente con ferramentas e datos externos a través do Model Context Protocol. Configura
servidores nun ficheiro .deepcerebra/mcp.json, por exemplo:
{
"mcpServers": {
"my-tools": {
"url": "https://example.com/mcp",
"disabled": false,
"allowlist": ["search_issues", "get_pr"],
"autoApprove": ["create_issue"],
"auth": { "type": "bearer", "tokenEnv": "MY_TOKEN" }
}
}
}As ferramentas MCP activadas están dispoñibles para o axente automaticamente cando son relevantes para a túa solicitude. Admítense
servidores locais (stdio) e remotos (http/sse).
allowlist, só esas ferramentas poden executarse.autoApprove.Se un servidor expón recursos MCP ou modelos de solicitude, o axente
obten automaticamente ferramentas para usalos (mcp_list_resources, mcp_read_resource,
mcp_list_prompts, mcp_get_prompt).
Engade un bloque auth a un servidor remoto. Os segredos admiten a interpolación ${ENV_VAR}:
// Static bearer token (literal or from env)
"auth": { "type": "bearer", "token": "${GITHUB_TOKEN}" }
"auth": { "type": "bearer", "tokenEnv": "GITHUB_TOKEN" }
// Custom header (e.g. API key)
"auth": { "type": "header", "header": "x-api-key", "value": "${MY_KEY}" }
// OAuth 2.0 client-credentials
"auth": {
"type": "oauth", "grant": "client_credentials",
"tokenUrl": "https://auth.example.com/oauth/token",
"clientId": "${MCP_CLIENT_ID}", "clientSecret": "${MCP_CLIENT_SECRET}",
"scope": "mcp.read mcp.write"
}Podes moldear como pensa e actúa o axente cunha única convención baseada en ficheiros — o
directorio .deepcerebra/ — que funciona de forma idéntica na aplicación de escritorio, na
aplicación web e na API. Na aplicación web, xestiona todo isto na
vista Axente; no escritorio e a través da API son ficheiros sinxelos que confirmas co teu proxecto.
A configuración descóbrese a partir de varios ámbitos; cando o mesmo elemento existe en máis dun, o de maior precedencia gaña:
equipo/organización < global (~/.deepcerebra) < espazo de traballo (<repo>/.deepcerebra)
(máis baixa) (máis alta)<repo>/.deepcerebra/…, confirmado co proxecto.~/.deepcerebra/…, os teus valores predeterminados persoais en todos os proxectos.As regras son instrucións persistentes — estándares de codificación, convencións de arquitectura, contexto de dominio — inxectadas no
prompt do sistema do axente. Viven como ficheiros Markdown en .deepcerebra/steering/, ademais do
estándar AGENTS.md sempre activo. O frontmatter controla cando se carga unha regra:
---
inclusion: fileMatch # always | fileMatch | auto | manual
globs: "src/**/*.ts" # or fileMatchPattern
name: api-design
description: REST conventions
---
# API design
- Use REST resource nouns, plural.always — en cada quenda (o predeterminado).fileMatch — só cando un ficheiro en contexto coincide con globs.auto — cando a túa solicitude coincide co name/description da regra.manual — só cando o referencias como #name ou /name.Un AGENTS.md raíz aplícase a todo o repositorio; un AGENTS.md aniñado (por exemplo,
services/api/AGENTS.md) aplícase só aos ficheiros dese cartafol. Na aplicación web, a
vista Axente → Dirección dálle a cada regra un selector de Ámbito
(Global / Proxecto / Equipo).
As habilidades son manuais reutilizables que o axente carga baixo demanda. Cada habilidade é un cartafol cun
SKILL.md en .deepcerebra/skills/:
---
name: deploy-release
description: How to cut and publish a versioned release.
disable-model-invocation: false # true => manual-only (/skill)
---
# Deploy a release
1. Bump the version, build, and test.
2. Tag and publish.O axente ve un catálogo lixeiro (nome + descrición) e extrae o corpo completo coa
ferramenta load_skill cando é relevante. Tamén podes invocar unha explicitamente con
/skill <name>. Establece disable-model-invocation: true para facer unha habilidade só manual.
Os hooks executan automatización en eventos do ciclo de vida. Defíneos como .deepcerebra/hooks/*.hook.json:
{
"title": "Format on save",
"event": "fileSave",
"filePattern": ["**/*.ts"],
"action": { "type": "shell", "command": "npm run lint:fix -- $FILE" },
"enabled": true
}Os eventos inclúen promptSubmit, preToolUse, postToolUse,
fileCreate, fileSave, fileDelete, preTask,
postTask, sessionStart, preCompact e agentStop
(tamén se aceptan as grafías de Cursor/Claude). Unha acción é shell (executar un comando) ou
agentPrompt (preguntar ao axente). Un hook preToolUse pode permitir,
denegar ou preguntar pola chamada á ferramenta que intercepta.
Os subaxentes son axentes especialistas que defines e delegas. Cada un é un ficheiro Markdown en
.deepcerebra/agents/ con frontmatter máis un corpo (o seu prompt do sistema):
---
name: security-reviewer
description: Audits a diff for security issues; read-only.
model: gpt-5
readonly: true
tools: [read_file, grep_files, list_directory]
background: false
---
You are a meticulous security reviewer…O axente principal delega con task (bloqueante), task_async +
task_status / task_result (segundo plano), ou task_parallel (fan-out).
Un plugin agrupa regras, habilidades, hooks, subaxentes e servidores MCP nun único paquete instalable en
.deepcerebra/plugins/<name>/, descrito por un manifesto plugin.json:
{
"name": "Acme Standards",
"version": "1.2.0",
"description": "Acme rules + skills + review agents.",
"enabled": true
}O contido do plugin fúndese coa menor precedencia, polo que as túas propias regras e habilidades sempre anulan as dun plugin.
Desactiva un plugin con "enabled": false ou un ficheiro marcador .disabled.
DCC_ORG_CONFIG_DIR a un directorio .deepcerebra compartido, ou configurando regras co
ámbito Equipo na aplicación web.O Estudio de Fluxos de Traballo é un deseñador visual para a automatización multi-axente. Compós etapas — cada unha un axente, un paso especialista ou unha primitiva de control — nun gráfico, conéctalas con dependencias e executa toda a orquestración no motor con progreso en tempo real por etapa, orzamentos e portas de aprobación humana. Os fluxos de traballo gárdanse como unha definición YAML/JSON portátil que podes exportar, importar, versionar en Git e executar desde a API ou CLI.
| Tipo de etapa | Que fai |
|---|---|
agent | Unha quenda de axente coas habilidades e ferramentas que anexas. |
spec.requirements / spec.design / spec.execute |
Entrega primeiro a especificación: borrador de requisitos, deseño, despois divídese en tarefas e execútase — cada unha con porta. |
documents.generate | Produce un documento pulido a partir das saídas da etapa anterior. |
fan_out | Investigación ampla paralela en moitos subtemas con síntese. |
map / loop / switch |
Primitivas de control: executa un corpo por elemento, repite ata unha condición ou ramifica en casos. |
verify / browser_verify |
Executa probas ou comandos no sandbox; verifica unha UI en execución con automatización do navegador. |
orchestrate | Enrutamento dinámico: un axente orquestrador le a solicitude e a envía aos mellores axentes descendentes a través de eventos. |
external.agent | Chama a un axente de terceiros rexistrado a través de HTTP (A2A) coma se fose unha etapa nativa. |
eval | Puntúa unha saída ascendente fronte a comprobacións (contén / regex / lonxitude / xuíz LLM); falla por debaixo dun limiar. |
db.provision | Xera unha capa de datos propia: docker-compose para a base de datos,
migracións SQL versionadas, datos de semente, modelo .env e un ERD Mermaid; scaffold de autenticación opcional;
pode aplicar migracións a SQLite inmediatamente. |
ci.generate | Xera un pipeline CI/CD listo para confirmar (GitHub Actions, GitLab CI, ou Azure Pipelines) con lint → test → scan → build → deploy e promoción de ambiente. |
deploy.package | Xera activos de despregamento de produción: Dockerfile multi-etapa, docker-compose, manifestos de Kubernetes ou un gráfico Helm — ficheiros que posúes e confirmas. |
test.generate | Xera suites de unidades / API / E2E para a aplicación construída máis unha matriz de trazabilidade de requisitos a probas. |
test.verify | Executa unha suite de probas (pytest, vitest, jest, Playwright) e controla a execución pola súa taxa de aprobación. |
security.audit | Escanea dependencias en busca de vulnerabilidades coñecidas e a árbore en busca de segredos codificados; publica eventos de alerta e escribe un informe de achados. |
preview | Inicia a aplicación xerada localmente e mostra o seu URL en vivo no panel de execución
(ligazón + marco en liña) a través dun evento preview.ready. |
design.import | Converte unha imaxe de deseño de UI (captura de pantalla, maqueta, exportación de Figma) nunha especificación de implementación estruturada para etapas posteriores. |
Cada etapa — independentemente do tipo — pode publicar e subscribirse a eventos tipados no bus de eventos do espazo de traballo, de modo que os axentes se coordinan como servizos nunha rede de mensaxes en lugar de só a través do DAG:
lifecycle, agent,
business, data, system, schedule, chat,
external ou alert — filtrables en subscricións e reprodución.trigger (a etapa execútase cando chega un evento coincidente; unha
execución con etapas aparcadas permanece residente como escoitando), gate (unha porta de máquina aprobada por
un evento en lugar dun clic humano) e data (a carga útil fúndese no
contexto da etapa).agent.<stage-id>.request.triggers: dun fluxo de traballo ármao para iniciarse en
webhooks de entrada, programacións cron, eventos ou chat — mesmo cando o
Estudio está pechado.Os axentes que reaccionan a eventos poden declarar unha cola duradeira con nome para que os eventos coincidentes nunca se perdan mentres o axente está ocupado ou antes de que unha execución estea á escoita. Nunha subscrición de disparador, establece
queue: <name> — o motor vincula ese tema a unha cola FIFO no bus de eventos do espazo de traballo (persistida en .deepcerebra/workflows/events/queues/). Cada evento coincidente publicado a partir dese momento é capturado na cola; cando a etapa se fai executable, o motor extrae os eventos en orde de máis antigo primeiro e consúmeos un a un.
count por subscrición — require N eventos encolados (ou entregados) antes de que a subscrición sexa satisfeita (útil cando varios traballadores deben informar).GET /api/workflow/queues lista a profundidade e as vinculacións;
GET /api/workflow/queues/{name} asoma os eventos pendentes; os axentes de chat poden chamar a
event_queue_status e pop_queued_event.events:
subscribe:
- topic: ticket.created
mode: trigger
queue: triage-inbox # durable FIFO — events wait here for this agent
map:
payload.ticket_id: ticket_idUn semáforo limita cantas tarefas poden operar simultaneamente nun recurso compartido (protexido):
unha base de datos que se está a escribir, un almacén de variables global, un ficheiro ou un axente externo con límite de taxa. Adxunta un a calquera
etapa con semaphore: — antes de que se execute o traballo da etapa, o motor adquire un permiso do semáforo do espazo de traballo nomeado; o permiso é sempre liberado despois, mesmo se a etapa falla.
permits: 1 convérteo nun mutex: só unha tarefa á vez (en todas as execucións paralelas no espazo de traballo) executa o paso crítico; todas as demais tarefas esperan ata que o titular remate.
timeout_s por un permiso; se o recurso permanece á súa capacidade, a etapa falla visiblemente en lugar de quedar colgada para sempre.ttl_s; se un titular falla sen liberalo, o permiso caduca automaticamente para que o recurso nunca quede bloqueado.semaphore.<name>.waiting,
.acquired e .released; GET /api/workflow/semaphores
mostra a capacidade, os titulares e os permisos dispoñibles.acquire_semaphore, release_semaphore e
semaphore_status coordinan seccións críticas ad-hoc fóra dun fluxo de traballo.semaphore:
name: emr-db-writer
permits: 1 # mutex — one writer at a time
timeout_s: 300 # fail if still waiting after 5 minutes
ttl_s: 900 # auto-release crashed holders after 15 minutesO encontro espera ata que se cumpran múltiples condicións de evento antes de que o seguinte paso proceda — o oposto a "o primeiro evento gaña". Establece join: all no bloque events: da etapa: cada subscrición de disparador debe ser satisfeita antes de que a etapa se execute. Combínao con count: N por subscrición cando varios axentes (ou varios informes dun axente) deben rexistrarse — por exemplo, a aprobación do deseño, a finalización das probas e a aprobación de seguridade antes de que se execute unha etapa de lanzamento.
join: any (predeterminado) — a etapa execútase cando a primeira subscrición de disparador é satisfeita.join: all — encontro: cada subscrición de disparador (cada unha co seu propio tema, filtro de clase e count opcional) debe ser satisfeita; só entón a etapa faise executable.trigger_events
e expóñense ás plantillas como inputs.events (unha lista de obxectos de evento con cargas útiles).events:
join: all # rendezvous — wait for EVERY subscription below
subscribe:
- topic: design.approved
mode: trigger
- topic: tests.passed
mode: trigger
- topic: security.cleared
mode: trigger
count: 1As etapas escollen ferramentas do mesmo rexistro que usa o axente de chat:
create_database, apply_migrations e dump_schema para capas de datos propias.docker_build / docker_push, compose up/down, despregamentos SSH e
cloud-CLI (Fly, Render, Railway, Vercel), tamén seguros para simulación.Class.method) en matemáticas, procesamento de sinais, controis, estatísticas e moito máis./v1 expón execucións, eventos, disparadores, modelos e xeración para CI e integracións.db.provision → implementación → probas xeradas → auditoría de seguridade → empaquetado de despregamento →
xeración de CI, cunha porta humana antes do empaquetado — un camiño completo de breve a produción que podes adaptar en
minutos.O completado predictivo con Tabulador ofrece suxestións de código en liña, para encher no medio, mentres escribes no editor — acepta unha suxestión con Tab. É unha función optativa tanto no motor como no editor web.
DCC_TAB_COMPLETE=1. O editor chama ao
punto final POST /api/complete do motor, que devolve só o texto a inserir no cursor.VITE_TAB_COMPLETE=1, ou no tempo de execución con
localStorage.setItem('dcc.tabComplete', '1') (despois recarga).Abre Facturación desde a barra lateral para xestionar o teu plan e uso. O uso da IA mídese en créditos en dólares estadounidenses baseados nos tokens consumidos polos modelos subxacentes.
| Plan | Prezo mensual | Uso de IA mensual incluído |
|---|---|---|
| Básico | $20 | $10 |
| Pro | $75 | $30 |
| Ultimate | $200 | $150 |
Unha chave API de gateway (un token de acceso persoal) permíteche usar a API pública e CLI de DeepCerebra de forma programática.
read, chat, code, agent
— e unha caducidade opcional en días (en branco = nunca).Úsaa coa CLI ou a API en deepcerebra.ai:
dcc config set endpoint https://deepcerebra.ai
dcc config set api-key <your-key>
# or as a Bearer token
curl -H "Authorization: Bearer <your-key>" https://deepcerebra.ai/v1/...Podes renomear ou eliminar (revogar) unha chave en calquera momento; cada chave mostra o seu prefixo, ámbitos, creación/caducidade e data do último uso.
Cambia a Chrome, Edge ou Brave, ou usa Abrir desde Git no seu lugar.
Fai clic en Deter, despois reformula cunha suxestión ou restrición concreta.
dcc-bridge está en execución e que o dispositivo mostra en liña.1234) cun
modelo cargado.--gateway
(wss://deepcerebra.ai ou wss://deepcerebra.io) — os dous sitios son
despregamentos separados, e un token dun nunca funciona no outro.Abre ou crea unha rama de traballo antes de usar Integrar para abrir unha solicitude de extracción.
Aínda tes problemas? Contacta con support@deepcerebra.ai.
Discovery é un chatbot de investigación para as túas bases de datos e documentos.
En lugar de responder cunha única consulta, funciona como un analista: formula hipóteses,
executa unha serie de sondas protexidas (SQL, grafo, busca de documentos, comprobacións de esquemas, corroboración web), descarta as
explicacións que a evidencia refuta e sintetiza unha resposta fundamentada — con gráficos e un
recibo de custo transparente. Ábreo desde a icona do compás na barra de actividade
(/app/discovery).
Un Espazo agrupa todo o que unha liña de investigación necesita: conexións a bases de datos, coleccións de documentos, instrucións para o analista e orzamentos. Crea un con + Novo espazo, e logo usa o panel de configuración da dereita para:
Escribe unha pregunta como llo farías a un colega — por exemplo "Por que diminuíu o volume de exploracións de resonancia magnética en marzo?". O taboleiro de investigación transmite todo o proceso en directo:
As preguntas de seguimento continúan o mesmo fío, polo que o analista mantén o seu contexto.
Os gráficos renderízanse en liña no taboleiro de investigación. Usa Exportar para descargar a consulta completa — a resposta, as hipóteses, a evidencia e os gráficos — como un informe HTML autocontido ou un PDF con calidade de impresión, deseñado co sistema de deseño de neón.
Cada espazo ten orzamentos por consulta: un número máximo de sondas, roldas de investigación, segundos e USD. O motor detense de forma limpa ao alcanzar o límite e informa do que atopou ata o momento. O custo de cada sonda detállase no recibo, para que sempre saibas onde se gastou.
/v1/discovery/* cun
PAT que leva o ámbito discovery (créao en Conta → Tokens de API).
As consultas de streaming usan SSE. Os executores externos poden tomar prestada só a planificación investigativa a través da Thinking API
(/v1/think/*, ámbito think).pip install deepcerebra-discovery, e logo
DiscoveryClient(base_url, token).ask(space_id, question).discovery.ask) a calquera fluxo de traballo para executar unha investigación como un paso de pipeline; a resposta,
os gráficos e o recibo flúen ás etapas posteriores.discovery_ask e
discovery_list_spaces como ferramentas MCP, para que os clientes MCP externos tamén poidan executar investigacións.