Skip to content

DeepTutor: Lifelong Personalized Tutoring. https://deeptutor.info/.

92.6 KB
Raw Blame

DeepTutor

DeepTutor: Tutoria Personalizada Vitalícia

Documentação — deeptutor.info  Colaborar — trabalhe connosco

Repositório em destaque do dia no GitHub HKUDS/DeepTutor | Trendshift Classificação do histórico de estrelas

English  简体中文  繁體中文  日本語  Español  Français  Arabic  Русский  Hindi  Português  Thai  Polski

Python 3.11+ Next.js 16 License GitHub release arXiv

Discord Feishu WeChat

Recursos · Começar · Explorar · CLI · Ecossistema · Comunidade


🤝 Damos as boas-vindas a todo tipo de contribuições! Vote em itens do roadmap ou proponha novos em Roadmap, e consulte o nosso Guia de Contribuição para a estratégia de branches, padrões de código e como começar.

📰 Notícias

  • 2026-09-20 🎉 Atingimos 40k estrelas em 9 meses! Continuaremos a expandir o ecossistema de aprendizagem do DeepTutor.
  • 2026-05-22 🌐 Site oficial de documentação disponível em deeptutor.info — guias, referências e tours de capacidades num só lugar.
  • 2026-04-19 🎉 Atingimos 20k estrelas em 111 dias! Obrigado pelo apoio incrível rumo a uma tutoria verdadeiramente personalizada e inteligente para todos.
  • 2026-04-10 📄 O nosso artigo está agora no arXiv! Leia o preprint para saber mais sobre o design e as ideias por trás do DeepTutor.
  • 2026-02-06 🚀 Atingimos 10k estrelas em apenas 39 dias! Um enorme obrigado à nossa incrível comunidade pelo apoio!
  • 2026-01-01 🎊 Feliz Ano Novo! Junte-se ao nosso Discord, WeChat ou Discussions — juntos damos forma ao futuro do DeepTutor!
  • 2025-12-29 🎓 DeepTutor está oficialmente lançado!

✨ Recursos Principais

O DeepTutor é um espaço de trabalho de aprendizagem nativo de agentes que conecta tutoria, resolução de problemas, geração de quizzes, pesquisa, visualização e prática de domínio num sistema extensível.

  • Um runtime para todos os modos — Chat, Ask Questions, Quiz, Research, Visualize, Solve, Mastery Path, Immersive Reading e Audio Overview partilham o mesmo runtime de capacidades e o mesmo contexto de sessão, mantendo loops e pipelines específicos para cada finalidade.
  • Task Board — acompanhe tarefas de estudo em Por fazer, Em curso e Concluído, com notas, arrastar e largar ou botões de movimentação acessíveis por teclado, e um arquivo do qual pode restaurá-las. Os cartões permanecem no workspace atual e seguem as definições de aparência e idioma existentes; não é necessário configurar um modelo.
  • Contexto de aprendizagem conectado — bases de conhecimento, livros, páginas do caderno de aprendizagem, Favoritos, bancos de questões, personas e Memory podem ser reutilizados nos fluxos de trabalho que os suportam, sujeitos às concessões da conta e às políticas de aprendizagem.
  • Aprendizagem imersiva por vídeo — adicione links do YouTube ou Bilibili ao Reading para reprodução nativa, pesquisa de transcrições, tutoria fundamentada em marcas temporais, notas guardadas e progresso retomável; as legendas e a navegação no YouTube podem usar uma instância Invidious configurada pelo administrador.
  • Subagentes e Partners — a partir do Chat, consulte um harness de agente ao vivo (Claude Code, Codex, Grok CLI, Antigravity, Kimi, opencode, MiMo, Hermes, OpenClaw ou DeepSeek) ou um Partner, importe conversas anteriores e execute companheiros IM persistentes no mesmo cérebro.
  • Conhecimento multi-motor — bibliotecas RAG com versões: LlamaIndex, PageIndex, GraphRAG, LightRAG, um LightRAG Server remoto, bases de conhecimento WeKnora auto-hospedadas, uma biblioteca Tencent IMA ou MarginNote 4, um arquivo Kiwix ZIM conectado, ou um vault Obsidian vinculado, com análise de documentos conectável. Consulte os modelos de função nativos do LightRAG para configurações independentes de extração, consulta e visão, criação apenas com predefinições e reconstruções confirmadas.
  • Ferramentas e habilidades extensíveis — ferramentas integradas, servidores MCP, aplicações CLI, modelos de geração de imagem / vídeo / voz e habilidades da comunidade instaláveis do EduHub.
  • Memória inspecionável — rastreamentos L1, resumos de superfície L2 e síntese L3 tornam a personalização visível e editável; o Memory Graph liga os factos L2 às evidências L1 e a síntese L3 às superfícies contribuintes.

🚀 Começar

Deixe o Seu Agente Configurar o DeepTutor

Copie este prompt para o seu agente de IA com acesso ao terminal (como Codex ou Claude Code):

Help me install and configure the current dev version of DeepTutor from https://github.com/HKUDS/DeepTutor.
Clone the dev branch, or inspect and reuse my existing checkout, and read SKILL.md and
docs-for-dev/AGENT_SETUP.md first. Follow that guide to prepare the environment,
configure my model provider, verify the setup, and start the Web app.
Ask me for any missing provider, model, or credential-source information;
do not print API keys. Preserve my existing files and settings, and finish
with the access URL and the results of your checks.

O guia de configuração por agentes cobre todo o processo, incluindo a configuração não interativa pela CLI. Para instalar por conta própria, escolha um dos caminhos abaixo.

O DeepTutor inclui quatro caminhos de instalação. Todos partilham o mesmo layout de diretório de runtime: as configurações privadas vivem em data/user/settings/ sob o diretório a partir do qual é iniciado (ou sob DEEPTUTOR_HOME / deeptutor start --home se definido explicitamente). Consulte Persistência de Dados Locais para o layout completo de armazenamento, o suporte de bases de dados e as notas de cópia de segurança. Para a aplicação completa, o fluxo recomendado é escolher um diretório de runtime → instalar → deeptutor init → deeptutor start.

Experimentar com Docker num Único Comando

Se ainda não tiver o Docker instalado, instale o Docker primeiro. Depois experimente a aplicação completa sem configurar Python nem Node.js:

docker run --rm --name deeptutor \
  -p 127.0.0.1:3782:3782 \
  -v deeptutor-data:/app/data \
  ghcr.io/hkuds/deeptutor:latest

Abra http://127.0.0.1:3782, configure provedores de modelos em Settings → Providers e prima Ctrl+C quando terminar. O volume nomeado deeptutor-data guarda as configurações e os dados locais para a próxima execução.

Espaço de Trabalho de Conteúdo

O Content Workspace é separado do espaço de trabalho de runtime privado do DeepTutor. É a pasta que os agentes podem ler, com os ficheiros gerados sob outputs/<capability>/<session>/<turn>/. Os workspaces personalizados isolam conversas, materiais de aprendizagem, progresso e caches numa árvore privada .deeptutor/data/ que as ferramentas de ficheiros não podem explorar. As definições, credenciais e Memory continuam partilhadas ao nível da conta.

Sem configuração, o content workspace é <runtime-home>/data/user/workspace. As instalações locais via PyPI, CLI e código-fonte podem escolher pastas em Settings → Workspaces; defina a pasta predefinida com:

deeptutor workspace show
deeptutor workspace set /absolute/path/to/my-folder
deeptutor workspace reset

As capacidades inspecionam o workspace selecionado através das ferramentas de workspace integradas. O modelo recebe apenas caminhos relativos como outputs/...; quando usa workspace_present, a UI apresenta um instantâneo autenticado e que pode ser aberto. O mesmo caminho relativo exato também funciona num link ou imagem Markdown normal. Alterar o ficheiro de origem mais tarde não altera um instantâneo já apresentado.

O Espaço de Aprendizado gere a biblioteca de recursos. Em Settings → Workspaces, atribua Skills, serviços MCP e bases de conhecimento a cada workspace, ou mantenha as suas regras de acesso existentes. Os workspaces existentes conservam o acesso atual até que seja guardada uma seleção. As atribuições referenciam os recursos originais sem copiar credenciais nem índices de conhecimento; as skills específicas de um workspace podem substituir as versões partilhadas. Consulte as atribuições de recursos do workspace.

A execução é apenas de leitura fora de outputs/. Copiar um ficheiro gerado para outro local dentro do content workspace requer uma confirmação explícita Allow once para essa origem e destino exatos. Uma sandbox de sistema ou o executor Docker aplica esse limite quando disponível; o fallback local de subprocesso restrito é apresentado como best effort nas definições de Workspace.

Opção 1 — Instalar a partir do PyPI · aplicação web local completa + CLI, sem necessidade de clonar

Instalação modular 1.7.0: use deeptutor[full] para a aplicação Web e a CLI, ou deeptutor para o chat básico. Os módulos de funcionalidades têm de corresponder à versão do núcleo; a versão 1.6.15 e anteriores usam o layout de pacotes anterior. Para desenvolver no dev atual, siga as instruções de código-fonte abaixo ou compile wheels locais. Requer Python 3.11–3.14 e um runtime Node.js 20+ no PATH (o servidor standalone Next.js empacotado é iniciado por deeptutor start).

mkdir -p my-deeptutor && cd my-deeptutor
pip install -U "deeptutor[full]"
deeptutor init     # prompts for ports + LLM provider + optional embedding/search
deeptutor start    # starts backend + frontend; keep the terminal open

deeptutor init solicita a porta de backend (predefinição 8001), a porta de frontend (predefinição 3782), provedor LLM / URL base / chave API / modelo, um provedor de embeddings opcional para Base de Conhecimento / RAG e um provedor de pesquisa opcional para Web Search.

Atualizar para 1.7.0: pare a aplicação e faça uma cópia de segurança do diretório de runtime. Use python -m pip install --upgrade "deeptutor[full]==1.7.0", seguido de python -m pip check e deeptutor module list. Se o pacote legado deeptutor-cli estiver instalado, execute primeiro python -m pip uninstall deeptutor-cli e depois o comando de atualização (adicionando opcionalmente deeptutor-cli==1.7.0). A CLI antiga é proprietária de ficheiros Python partilhados, pelo que atualizá-la na mesma transação pode eliminar o novo núcleo. Desinstalar o pacote mantém intactos os dados do diretório de runtime. Mantenha o mesmo DEEPTUTOR_HOME e as definições existentes. Na versão 1.7.0, pip install -U deeptutor isoladamente seleciona apenas o núcleo; use [full] para pedir o perfil de instalação da aplicação completa. Para pacotes compilados localmente, siga as instruções de atualização com wheels locais.

Após deeptutor start, abra a URL do frontend impressa no terminal — por predefinição http://127.0.0.1:3782. Prima Ctrl+C nesse terminal para parar tanto o backend como o frontend. Omitir deeptutor init é adequado para um teste rápido; a aplicação arranca com portas predefinidas e configuração de modelo vazia, configure-as depois em Settings → Providers e Language models.

Transcrição do microfone no navegador: os adaptadores STT compatíveis com OpenAI enviam o áudio do navegador ao provedor sem conversão local. Os adaptadores STT nativos da DashScope e da Volcengine convertem WebM/Opus do navegador para WAV de 16 kHz e requerem um executável ffmpeg no PATH do DeepTutor. Um WAV PCM mono canónico de 16 kHz dispensa esta conversão. Em instalações PyPI no Windows que usem qualquer um destes adaptadores nativos, instale o FFmpeg, adicione o diretório bin ao PATH do serviço e reinicie o DeepTutor. As falhas de conversão aparecem abaixo do campo de entrada do chat.

Opção 2 — Instalar a partir do Código-Fonte · desenvolver num checkout

Para desenvolvimento num checkout. Use Python 3.11–3.14 e Node.js 22 LTS para coincidir com CI e Docker.

git clone --branch dev https://github.com/HKUDS/DeepTutor.git
cd DeepTutor

# Create a venv (macOS/Linux). Windows PowerShell:
#   py -3.11 -m venv .venv ; .\.venv\Scripts\Activate.ps1
python3 -m venv .venv && source .venv/bin/activate
python -m pip install --upgrade pip

# Install backend + frontend deps
python -m pip install -r requirements/full.txt
python -m pip install -e . --no-deps
( cd web && npm ci --legacy-peer-deps )

deeptutor init
deeptutor start --dev

deeptutor start compila o frontend web/ local para produção uma vez e reutiliza-o; --dev executa o Next.js com HMR. O layout de configuração, as portas e o Ctrl+C correspondem à Opção 1.

Ambiente Conda (em vez de venv)
conda create -n deeptutor python=3.11
conda activate deeptutor
python -m pip install --upgrade pip
Extras de instalação opcionais — motores RAG / dev / partners / matrix / math-animator
python scripts/install_extras.py rag-lightrag    # Built-in LightRAG engine (exact supported SDK)
python scripts/install_extras.py graphrag        # Microsoft GraphRAG engine (Python 3.11–3.13)
python scripts/install_extras.py dev             # tests/lint tools
python scripts/install_extras.py partners        # Partner IM channel SDKs
python scripts/install_extras.py video-learning  # captions for reading/video-learning
python scripts/install_extras.py matrix          # Matrix channel without E2EE/libolm
python scripts/install_extras.py matrix-e2e      # Matrix E2EE; requires libolm
python scripts/install_extras.py math-animator   # Manim addon; requires LaTeX/ffmpeg/system libs
python scripts/install_extras.py edge-tts        # Optional free speech provider and video-lesson narration

Video Lesson: escolha Video Lesson no chat ou execute deeptutor run video_lesson "Explain a concept". O backend precisa de Node.js 22+ e npm. A primeira utilização descarrega versões fixadas dos pacotes Remotion e um interpretador JavaScript WebAssembly; o Docker não é necessário. As verificações de fotogramas correm dentro do interpretador, sem acesso ao sistema de ficheiros do host, credenciais, rede ou APIs de processos, com limites de memória e execução. O cancelamento interrompe o processo de compilação. As implementações locais e em contentores usam o mesmo caminho de execução, sem fallback fora da sandbox. A lição resultante é reproduzida no navegador, com legendas quando a narração opcional não está disponível.

Ajustes de dependências do frontend e resolução de problemas do servidor de desenvolvimento

Alterar dependências do frontend: execute npm install --legacy-peer-deps para atualizar web/package-lock.json, depois confirme tanto web/package.json como web/package-lock.json.

Servidor de desenvolvimento bloqueado: se deeptutor start --dev reportar um frontend existente que não responde, pare o PID que imprime. Se não houver nenhum processo Next.js em execução, os ficheiros de bloqueio estão desatualizados — remova-os e tente novamente:

rm -f web/.next/dev/lock web/.next/lock
deeptutor start --dev
Opção 3 — Docker · um contentor autossuficiente

Um contentor para a aplicação web completa. Imagens no GitHub Container Registry:

  • ghcr.io/hkuds/deeptutor:latest — lançamento estável mais recente
  • ghcr.io/hkuds/deeptutor:<version> — lançamento exato sem o v inicial (por exemplo, :1.6.3); os pré-lançamentos recebem apenas a respetiva tag de versão

Consulte CONTAINERIZATION.md para implementações podman/rootless/read-only-rootfs e o guia completo por instalação.

docker run --rm --name deeptutor \
  -p 127.0.0.1:3782:3782 \
  -v deeptutor-data:/app/data \
  ghcr.io/hkuds/deeptutor:latest

Para escolher uma pasta de conteúdo do host no arranque do contentor, monte-a no caminho estável do contentor e bloqueie o DeepTutor a esse caminho:

mkdir -p "$PWD/deeptutor-workspace/outputs"
docker run --rm --name deeptutor \
  -p 127.0.0.1:3782:3782 \
  -v deeptutor-data:/app/data \
  -v "$PWD/deeptutor-workspace:/workspace" \
  -e DEEPTUTOR_WORKSPACE_ROOT=/workspace \
  -e DEEPTUTOR_WORKSPACE_ALLOWED_ROOTS=/workspace \
  ghcr.io/hkuds/deeptutor:latest

Para o Compose, defina DEEPTUTOR_WORKSPACE_HOST=/absolute/host/folder antes de executar python scripts/docker_compose.py up -d. Quando omitido, usa ./data/user/workspace. Os caminhos do Docker são selecionados no arranque e, por isso, aparecem bloqueados na página de definições Web.

Apenas 3782 precisa de ser publicado. O navegador comunica exclusivamente com a origem do frontend; o middleware Next.js (web/proxy.ts) reencaminha /api/* e /ws/* para o backend FastAPI dentro do contentor. Publicar 8001 (-p 127.0.0.1:8001:8001) é opcional — útil apenas para aceder à API diretamente com curl ou scripts.

Abra http://127.0.0.1:3782. O contentor cria /app/data/user/settings/*.json no primeiro arranque; configure os provedores de modelos a partir da página de Settings web. A configuração, as chaves API, os logs, o Content Workspace predefinido, a memória e as bases de conhecimento persistem no volume deeptutor-data. Em vez disso, um Content Workspace montado separadamente persiste no seu caminho de host. Extras opcionais pertencem à implementação, não a uma shell: defina DEEPTUTOR_EXTRAS (e DEEPTUTOR_APT_PACKAGES para bibliotecas de sistema) e cada contentor iniciado a partir dela reaplica-os, ao passo que um docker exec … pip install seria perdido no compose down seguinte.

  • Portas de host diferentes: altere o lado esquerdo de cada mapeamento -p host:container (ex. -p 127.0.0.1:8088:3782). Se alterar as portas do lado do contentor em /app/data/user/settings/system.json, reinicie e atualize o lado direito de cada mapeamento para corresponder.
  • Desconectado: adicione -d, depois docker logs -f deeptutor para seguir, docker stop deeptutor para parar, docker rm deeptutor antes de reutilizar o nome. O volume deeptutor-data mantém os dados privados de runtime e o Content Workspace predefinido entre reinicializações; um Content Workspace montado separadamente persiste no seu caminho de host.

Docker remoto / proxy inverso: o navegador comunica apenas com a origem do frontend (:3782); o middleware Next.js dentro do contentor reencaminha /api/* e /ws/* para o servidor de backend do lado do servidor. Para o caso comum de contentor único, não configura uma base de API — apenas aponte o seu proxy inverso / terminador TLS para :3782. Só precisa de uma base de API para uma implementação separada (backend num contentor/host separado): defina next_public_api_base em data/user/settings/system.json para o endereço interno que o servidor frontend usa para alcançar o backend (é lido do lado do servidor, nunca enviado ao navegador).

{
  "next_public_api_base": "http://backend:8001"
}

next_public_api_base_external (e o seu alias public_api_base) são aceites como fallbacks de menor precedência. CORS usa origens de frontend, não URLs de API. Com a autenticação desativada, o DeepTutor permite origens normais de navegador HTTP/HTTPS por predefinição. Com a autenticação ativada, adicione as origens exatas do frontend:

{
  "cors_origins": ["https://deeptutor.example.com"]
}
Ligar ao Ollama / LM Studio / llama.cpp / vLLM / Lemonade no host

Dentro do Docker, localhost é o próprio contentor, não a sua máquina host. Para alcançar um serviço de modelo em execução no host, use o host gateway (recomendado):

docker run --rm --name deeptutor \
  -p 127.0.0.1:3782:3782 -p 127.0.0.1:8001:8001 \
  --add-host=host.docker.internal:host-gateway \
  -v deeptutor-data:/app/data \
  ghcr.io/hkuds/deeptutor:latest

Depois em Settings → Providers, aponte o URL Base do provedor para host.docker.internal:

  • Ollama LLM: http://host.docker.internal:11434/v1
  • Ollama embedding: http://host.docker.internal:11434/api/embed
  • LM Studio: http://host.docker.internal:1234/v1
  • llama.cpp: http://host.docker.internal:8080/v1
  • Lemonade: http://host.docker.internal:13305/api/v1

O Docker Desktop (macOS/Windows) geralmente resolve host.docker.internal sem --add-host. No Linux, o flag é a forma portátil de criar esse nome de host no Docker Engine moderno.

Alternativa para Linux — rede do host: adicione --network=host e remova os flags -p. O contentor partilha a rede do host diretamente, por isso abra http://127.0.0.1:3782 (ou o frontend_port em system.json), e os serviços do host podem ser alcançados com URLs de localhost normais como http://127.0.0.1:11434/v1. Note que a rede do host expõe as portas do contentor diretamente no host e pode entrar em conflito com serviços existentes — para os manter no loopback, defina BACKEND_HOST=127.0.0.1 e FRONTEND_HOST=127.0.0.1 (consulte CONTAINERIZATION.md).

Opção 4 — Apenas CLI · sem UI web, a partir de um checkout de fonte

Quando não precisa da UI Web, use a CLI deste checkout e dispense Node/npm. O código-fonte disponibiliza todos os módulos presentes no repositório e requer as respetivas dependências Python. Para uma instalação mínima com a versão modular 1.7.0, use o wheel do núcleo deeptutor e adicione os módulos de funcionalidades separadamente.

git clone --branch dev https://github.com/HKUDS/DeepTutor.git
cd DeepTutor

# Create a venv (macOS/Linux). Windows PowerShell:
#   py -3.11 -m venv .venv-cli ; .\.venv-cli\Scripts\Activate.ps1
python3 -m venv .venv-cli && source .venv-cli/bin/activate
python -m pip install --upgrade pip

python -m pip install -r requirements/full.txt
python -m pip install -e . --no-deps
deeptutor init --cli
deeptutor chat

deeptutor init --cli partilha o mesmo layout data/user/settings/ que a aplicação completa, mas omite as solicitações de portas de backend/frontend. Continua a oferecer os seletores Embedding e Search (escolha Skip quando não precisar deles), escreve os ficheiros de runtime essenciais (system.json, auth.json, integrations.json, interface.json, model_catalog.json, main.yaml, agents.yaml) e solicita o provedor LLM e o modelo ativos.

Comandos comuns
deeptutor chat                                          # interactive REPL
deeptutor chat --capability deep_solve --kb my-kb
deeptutor run chat "Explain Fourier transform"
deeptutor run deep_solve "Solve x^2 = 4" --kb my-kb
deeptutor kb create my-kb --doc textbook.pdf
deeptutor memory show
deeptutor config show

Esta instalação a partir do código-fonte inclui dependências de servidor, mas dispensa a configuração do frontend. Mantenha o checkout, pois a instalação editável aponta para ele. Para adicionar a UI Web mais tarde, instale Node.js 22 LTS, execute npm ci --legacy-peer-deps em web/ e depois execute deeptutor init e deeptutor start na raiz do projeto.

Sandbox de Execução de Código (skills de escritório) · executar código gerado pelo modelo para docx / pdf / pptx / xlsx

As skills de escritório integradas — docx / pdf / pptx / xlsx — funcionam fazendo com que o modelo escreva um script Python curto (python-docx, reportlab, openpyxl, …), o execute através da única ferramenta exec, e apresente o ficheiro guardado no workspace. Essas ferramentas são montadas sempre que um backend de sandbox está ativo. O DeepTutor seleciona o backend configurado mais robusto pela seguinte ordem:

  • Sidecar runner: DEEPTUTOR_SANDBOX_RUNNER_URL encaminha a execução para o serviço endurecido e de privilégios mínimos de Dockerfile.runner.
  • Linux bubblewrap: quando disponível, bwrap isola o processo e os ficheiros.
  • Fallback de subprocesso restrito: as instalações locais e de contentor único só o utilizam quando permitido; no Docker, o contentor continua a ser outro limite.

A configuração sandbox_allow_subprocess em data/user/settings/system.json (predefinição true) controla apenas o último fallback. Defina-a como false (ou exporte DEEPTUTOR_SANDBOX_ALLOW_SUBPROCESS=0) para recusar a execução por subprocesso quando não estiver disponível nenhum backend runner ou bwrap; isto não desativa esses backends mais robustos.

Referência de configuração — ficheiros de configuração sob data/user/settings/ (JSON/YAML)

Tudo sob data/user/settings/ é JSON/YAML simples. A página Settings é o editor recomendado; os registos de workspaces são guardados separadamente em data/user/.runtime/workspaces.sqlite3.

Ficheiro Propósito
model_catalog.json Ligações a provedores, perfis LLM, de tarefas, embeddings, pesquisa, TTS, STT, imagem e vídeo, credenciais e seleções ativas
system.json Portas de backend/frontend, base de API pública, CORS, verificação SSL, diretório de anexos e limites de carregamento/extração
auth.json Interruptor de autenticação opcional, nome de utilizador, hash de palavra-passe, configurações de token/cookie
integrations.json Configurações opcionais de PocketBase e integrações sidecar
interface.json Preferências de idioma da UI e de saída do modelo / tema / barra lateral
document_parsing.json Seleção do motor de análise e do modelo de descrição de imagens, endpoints remotos e opções específicas de cada motor
video_learning.json Provedor de legendas do YouTube, origens Invidious e acesso à conta, e definições de transcrições
main.yaml Predefinições de comportamento de runtime e injeção de caminhos
agents.yaml Configurações de temperatura e tokens de capacidades/ferramentas

As referências do Web Search são filtradas por predefinição: apenas são apresentados URLs públicos http/https sem credenciais incorporadas nem portas pouco comuns. As implementações podem adicionar uma política de domínios orientada para a educação em data/user/settings/system.json:

{
  "web_search_source_filtering": {
    "enabled": true,
    "blocked_domains": ["spam.example"],
    "trusted_domains": ["edu.cn", "arxiv.org"]
  }
}

Quando trusted_domains não está vazio, as referências ficam limitadas a esses domínios e aos respetivos subdomínios; blocked_domains tem sempre precedência.

O .env da raiz do projeto não é lido como ficheiro de configuração da aplicação. Para uma configuração mínima do modelo, guarde um URL Base e uma chave API em Settings → Providers; depois adicione e selecione um LLM em Language models. Adicione um perfil de embeddings apenas se planear usar funcionalidades de Base de Conhecimento / RAG.

Para API Route, selecione API Route em Settings → Providers e introduza uma chave API Route. A predefinição usa https://global.api-route.com/v1; depois adicione um modelo com o respetivo ID de modelo API Route em Language models. Consulte o guia de início rápido do API Route para configurar a chave e o modelo.

Os perfis LLM e de modelos de tarefa expõem uma definição de formato da API quando o respetivo provedor permite escolher. Mantenha Auto para o encaminhamento normal e fallback, ou escolha OpenAI Chat Completions, OpenAI Responses ou Anthropic Messages; o modo Responses forçado continua fechado em caso de falha. O campo persistido é api_format (auto, openai_chat, openai_responses ou anthropic); wire_api é um estado de compatibilidade derivado. As substituições Auto / Supported / Not supported por modelo abrangem chamadas de ferramentas, entrada de imagens, saída JSON e controlos de raciocínio.

Desinstalação e limpeza

O DeepTutor separa o código instalado, o seu espaço de trabalho de runtime privado e o Content Workspace opcional. Por predefinição, o espaço de trabalho de runtime é o diretório onde executa deeptutor init / deeptutor start; --home PATH ou DEEPTUTOR_HOME substitui-o. O estado privado da aplicação é o diretório data dentro desse espaço de trabalho, pelo que a linha do banner de arranque que começa por Workspace: identifica essa localização de runtime. Se Settings → Workspace apontar para outra pasta, faça uma cópia de segurança ou remova essa pasta de conteúdo separadamente; ela não é apagada intencionalmente ao desinstalar o DeepTutor.

  1. Pare a aplicação. Prima Ctrl+C no terminal que executa deeptutor start, ou execute deeptutor stop [--home PATH] para um launcher iniciado com --detach; pare também quaisquer Partners em execução e contentores Docker desconectados antes de eliminar dados.

  2. Remova os dados de runtime apenas se também quiser apagar todo o estado local. Isto inclui definições e chaves API, histórico de chat, sessões, Memory, Notebooks, Books, estado de Reading, Skills, estado de Partners, logs, Bases de Conhecimento, caches de análise, artefactos gerados e a cache de runtime do frontend empacotado.

    Primeiro copie o caminho exato de Workspace: do banner de arranque e confirme que o respetivo filho data é o diretório de dados do DeepTutor pretendido. Faça uma cópia de segurança se algo puder vir a ser necessário e, depois, mova esse diretório exato para o Lixo/Reciclagem do seu sistema operativo. Não execute um comando de eliminação recursiva contra um caminho relativo ou uma variável de ambiente não resolvida.

  3. Remova o pacote instalado. Use o comando correspondente à distribuição:

    python -m pip uninstall deeptutor
    python -m pip uninstall deeptutor-cli
    

    Se o ambiente virtual foi criado apenas para o DeepTutor, remova-o através do seu gestor de ambientes. Para uma instalação a partir do código-fonte, desative o ambiente, saia do diretório do código-fonte e execute git status --short dentro desse checkout exato. Só mova o checkout para o Lixo/Reciclagem depois de confirmar que não contém trabalho não relacionado ou não submetido.

  4. Para o caminho Docker, inspecione o contentor exato e o volume nomeado antes de os remover. A remoção do volume apaga permanentemente os dados geridos pelo Docker:

    docker ps -a --filter name=^/deeptutor$
    docker volume inspect deeptutor-data
    docker rm -f deeptutor
    docker volume rm deeptutor-data
    

📖 Explorar o DeepTutor

Comece por um workspace para uma disciplina ou projeto. A Página inicial, a Aprendizagem e os Recursos guardam as suas conversas, atividades de aprendizagem e materiais. Os Partners e a Personalização acompanham a conta entre workspaces. O tour abaixo mostra como estas áreas se ligam, seguido das configurações e da implementação multi-utilizador.

Se uma resposta perder uma restrição anterior, citar evidências fracas ou discordar do material selecionado, recolha os diagnósticos em REASONING_SAFETY_CHECKLIST.md antes de abrir uma issue.

Página inicial e navegação entre workspaces do DeepTutor
🏗️ Arquitetura do sistema
Arquitetura do sistema DeepTutor
💬 Chat — O Loop de Agente que Realmente Usa

Chat é a capacidade predefinida e o lugar onde a maior parte do trabalho começa. Um único thread pode conversar normalmente, chamar ferramentas, fundamentar-se em bases de conhecimento selecionadas, ler anexos, gerar imagens, consultar subagentes, escrever registos de notebook e continuar com o mesmo contexto entre turnos.

Espaço de trabalho de chat DeepTutor

O tutor chama ferramentas conforme necessário e pode pausar para fazer perguntas de esclarecimento. Personalizar página, no canto superior direito, escolhe os modos visíveis e os controlos de Skills, MCP, Partners, Preferências e entrada de voz. Em Prompts iniciais, adicione, edite ou remova os títulos e prompts de Explicar, Resolver, Praticar, Planear e Pesquisar. Guardar aplica as preferências da conta; Cancelar descarta as alterações e Restaurar predefinições repõe as escolhas originais.

Loop de agente de chat DeepTutor

As ferramentas ativáveis pelo utilizador são brainstorm, web_search, paper_search, zotero_search, reason e geogebra_analysis — mais imagegen e videogen depois de configurar o modelo de geração correspondente. Ferramentas contextuais como rag, kb_files, knowledge_frontier, read_source, read_memory, write_memory, read_skill, load_tools, exec, web_fetch, ask_user, list_favorites, save_favorite, write_note, search_notes, question_bank, github, consult_subagent, workspace_list, workspace_read, workspace_search, workspace_present e workspace_export montam automaticamente quando o turno tem o contexto certo.

O contexto é de dois tipos: o contexto de sessão fixo (capacidade, espaço de trabalho ou curso, ferramentas, bases de conhecimento, persona, modelo e estado de Reading / Mastery) persiste entre turnos; as referências únicas (ficheiros, histórico de chat, livros, secções de leitura, notebooks, entradas selecionadas do banco de questões, agentes importados) vêm do menu + para um único turno. O botão de voz transcreve apenas a mensagem atual.

Com o perfil completo, a página inicial mantém Chat, Ask Questions, Quiz, Visualize e Video Lesson a um clique de distância; Research para relatórios com citações e Solve para raciocínio desenvolvido ficam em Mais capacidades. Aprendizagem → Nova aprendizagem, acima de Toda a aprendizagem, abre uma página dedicada a Livros, Mastery Path, Immersive Reading e Prática. O controlo Personalizar página oculta ou repõe métodos de aprendizagem sem alterar os registos existentes; os módulos indisponíveis continuam excluídos. Reading reúne documentos, vídeo e áudio com citações verificadas, notas guardadas, leitura em voz alta natural a partir de trechos da fonte / ações de orientação de estudo / vocabulário / quiz / tradução e captura para notebooks.

🤝 Partner — Companheiros Persistentes no Mesmo Cérebro
Espaço de trabalho de partners DeepTutor

Os Partners são companheiros persistentes com a sua própria alma, política de modelo, biblioteca, memória e canais. Não são um motor de bot separado: cada mensagem web ou IM recebida torna-se um turno normal do ChatOrchestrator dentro do seu espaço de trabalho de conteúdo privado ou vinculado. Um partner é "um chat que tem personalidade e número de telefone."

Arquitetura de partners DeepTutor

Cada partner tem um SOUL.md, seleção de modelo, canais, política de ferramentas e biblioteca atribuída. A sua biblioteca pode copiar bases de conhecimento, skills e coleções de Favoritos para data/partners/<id>/workspace/, ou permanecer ligada aos ficheiros e recursos de um workspace existente; a identidade, as conversas e a memória do Partner continuam separadas. Os utilizadores autenticados que não sejam administradores mantêm sessões Partner e memória de relacionamento privadas, enquanto o Partner lê a sua memória pessoal em modo somente leitura; o tráfego de administrador, de grupo e não vinculado usa o âmbito Partner partilhado.

Configuração de canal IM por partner

A camada de canais é orientada por esquema e pode ligar-se a plataformas IM como Feishu, Telegram, Slack, Discord, DingTalk, QQ/NapCat, WeCom, WhatsApp, Zulip, Mattermost, Matrix, Mochat e Microsoft Teams dependendo dos extras instalados e das credenciais configuradas. Um partner também pode ser conectado como subagente e consultado a partir de um turno de chat normal — veja Meus Agentes abaixo.

Para uma configuração mais rápida, a página de canal do Partner pode criar uma aplicação Feishu/Lark ou um bot de IA WeCom, ou iniciar sessão numa conta pessoal de WeChat, a partir de um código QR desenhado no navegador em vez do log do servidor. O Feishu/Lark deteta o domínio da conta e guarda o utilizador que fez a leitura como o remetente permitido inicial. O WeCom mantém uma lista de permissões existente e, caso contrário, assume por predefinição todos os utilizadores que conseguem alcançar o bot, com um aviso visível de acesso aberto; os formulários de canal manuais permanecem disponíveis caso o protocolo de leitura de um provedor mude.

🧑‍🚀 Meus Agentes — Consultar e Importar Outros Agentes
Espaço de trabalho Meus Agentes DeepTutor

Meus Agentes transforma outros agentes em contexto para o DeepTutor, e faz duas coisas distintas. Conectar um agente ao vivo — Claude Code, Codex, Grok CLI, Antigravity, Kimi, opencode, MiMo Code, Hermes Agent, OpenClaw ou DeepSeek Harness na sua máquina, um gateway Hermes remoto ou um dos seus Partners — e consultá-lo a partir de dentro de um turno de chat: o DeepTutor executa mesmo o outro agente e transmite o seu trabalho para o painel de Atividade via a ferramenta consult_subagent. Selecione-o e o respetivo limite de rondas com o chip de Agente, ou filtre a mesma lista de agentes conectados com @; a escolha permanece associada à sessão.

Ligar o Grok CLI. Instale o Grok CLI da xAI na máquina que executa o backend do DeepTutor, execute grok login aí, e confirme que grok --help lista --output-format streaming-json. Depois abra Meus Agentes → Conectar, selecione Grok CLI e escolha um diretório de trabalho. A deteção verifica o suporte de protocolo do executável; não verifica o login nem o acesso ao modelo. O conector foi testado com o Grok CLI 1.0.3; comandos de terceiros não relacionados também chamados grok não são suportados.

Em Settings → Partners & Agents → Grok CLI, deixe o modelo e o esforço de raciocínio em branco para usar as predefinições da CLI, ou introduza valores suportados pela saída de grok models da sua conta. As instruções do sistema são passadas através de --rules. O modo de permissão predefinido é dontAsk: o Grok usa as suas próprias regras e o tratamento incorporado só de leitura, e recusa operações que precisem de aprovação. Esta é uma política de permissão da CLI, não uma sandbox do sistema de ficheiros. Modos mais amplos podem ser selecionados explicitamente nas definições; flags avançadas da CLI continuam disponíveis através de backends.grok.extra_args na API de definições de subagentes.

O Grok usa a sua própria autenticação e armazenamento de sessão; o DeepTutor não copia as suas credenciais. Consultas de seguimento retomam a sessão da ligação no mesmo diretório de trabalho. O texto e a atividade de ferramentas são transmitidos em direto; as cargas de pensamento privado são omitidas. A memória do Grok entre sessões está desativada por predefinição. Este conector suporta perguntas de texto e ferramentas da CLI, não o envio de imagens nem a importação de conversas anteriores do Grok. No Docker, instale e autentique o Grok dentro do contentor do backend; uma CLI instalada apenas na máquina do navegador não é alcançável.

Personalização da conta: agentes, personas, skills e ligações

Importar conversas anteriores — traga o seu histórico existente do ChatGPT, Claude Code e Codex como conversas pesquisáveis e retomáveis. Selecione conversations.json de uma exportação de dados oficial do ChatGPT para uma importação de instantâneo segura e idempotente, escolha o histórico do Claude por projeto / diretório de trabalho, ou escolha o histórico do Codex por data do calendário. Os agentes baseados em pastas continuam atualizáveis, de modo que o seu âmbito selecionado pode obter novas conversas. Referencie uma a partir de um turno do Chat via + → Meus Agentes, e o DeepTutor lê-a como uma transcrição de terceiros — permanece a conversa deles, não a voz própria do DeepTutor.

✍️ Caderno de Aprendizagem — Páginas, Fontes e Dito
Páginas do caderno de aprendizagem

O caderno de aprendizagem, anteriormente Co-Writer, organiza a sua escrita em páginas, subpáginas e blocos no workspace ativo. Importe documentos Word, organize uma árvore de páginas e insira registos originais dos Favoritos como evidência. As páginas mantêm o estado de gravação visível e podem ser exportadas para Markdown ou Word; o conteúdo interativo torna-se estático no Word.

Editor de blocos do caderno de aprendizagem e Dito

Discuta um trecho ou bloco com Dito: peça uma explicação, um exemplo, uma reescrita ou uma pergunta de prática. As conversas permanecem associadas à página e à linha relevantes. Reveja as alterações propostas antes de as aceitar, ou insira uma resposta abaixo da linha e continue a trabalhar. Os Favoritos preservam os registos das fontes; o caderno é onde constrói a sua própria compreensão.

📖 Book (Livro) — Livros Vivos dos Seus Materiais
Biblioteca de livros DeepTutor

Book converte fontes selecionadas num livro vivo interativo — não um PDF estático, mas um ambiente de leitura construído a partir de blocos tipados. Um livro pode começar a partir de bases de conhecimento, Favoritos, bancos de perguntas ou histórico de chat; o fluxo de criação propõe uma estrutura de capítulos antes de o conteúdo ser gerado, para que os utilizadores possam rever a forma em vez de aceitar uma saída cega de disparo único.

Bloco de quiz do Book   Estrutura e capítulos do livro   Bloco de widget interativo do Book

Cada capítulo compila em blocos tipados editáveis — texto, callouts, quizzes, cartões flash, linhas do tempo, código, figuras, HTML interativo, animações, gráficos de conceitos, mergulhos profundos e notas de utilizador — e cada página dispõe do seu próprio Page Chat. Insira, mova, regenere, reescreva ou mude o tipo de um bloco; os trechos selecionados entram numa caixa de entrada de capturas de aprendizagem sujeita a revisão. O progresso, os marcadores, as tentativas de quiz, as capturas e o Page Chat permanecem privados por leitor, mesmo quando um livro do administrador é partilhado em modo só de leitura ou para edição colaborativa; a eliminação de livros partilhados continua reservada ao administrador. Qualquer livro exporta para Markdown, as compilações longas pausam e retomam, e deeptutor book health / refresh-fingerprints assinalam divergências nas fontes.

📚 Centro de Conhecimento — Bibliotecas RAG Multi-Motor
Centro de Conhecimento DeepTutor

As bases de conhecimento são as coleções de documentos por trás do RAG — fundamentam os turnos do Chat, edições do caderno de aprendizagem, geração do Book e conversas do Partner. O que é distintivo é uma escolha de motores de recuperação: LlamaIndex (o padrão, vetor híbrido + BM25 com reranking opcional por cross-encoder e índices FAISS exact-flat ou HNSW), PageIndex (recuperação de raciocínio com citações ao nível da página, alojado ou OSS auto-hospedado), GraphRAG e LightRAG (recuperação de grafo de conhecimento), LightRAG Server (recuperação delegada a uma instância externa de LightRAG conectada via HTTP), WeKnora (recuperação a partir de uma base de conhecimento na sua implementação auto-hospedada, sem índice local nem cópia de documentos), Tencent IMA (uma biblioteca que cura no IMA — pesquisada, navegada e escrita de volta através da sua OpenAPI), MarginNote 4 (os seus dados de estudo MN4 — documentos, excertos, cartões de mapa mental e as ligações entre eles — enviados pelo Add-on da aplicação e navegados com ferramentas dedicadas), Kiwix (um arquivo ZIM pesquisável servido por HTTP sem indexação local), ou um vault Obsidian vinculado que o tutor lê e escreve no lugar. Cada KB está vinculada a um motor.

Criar uma base de conhecimento

Vai migrar uma biblioteca Obsidian, Hermes ou Markdown existente? Consulte o guia de migração de Knowledge para os caminhos de vault ligado e cópia indexada.

Ao criar uma KB, pode criar nova (carregar e indexar documentos), vincular existente (reutilizar um índice no local) ou conectar Kiwix (pesquisar um arquivo ZIM servido quando necessário). Escolha o workspace de armazenamento ao criar a KB; uma KB existente pode ser movida entre workspaces após uma pré-visualização, mantendo as atribuições e as referências guardadas. Uma KB também pode rastrear repositórios GitHub (repositório, branch, glob) ou URLs de sites de documentação (com profundidade de rastreio e número de páginas limitados, resincronizados a cada 24 h por predefinição); a sincronização compara hashes para detetar conteúdo adicionado, alterado ou removido, para que a documentação que segue se mantenha atual sem reenvio, e as pastas vinculadas capturam ficheiros locais novos ou alterados na sincronização. A reindexação escreve um novo diretório plano version-N e mantém os anteriores, pelo que um índice funcional nunca é destruído a meio de uma reconstrução. Um único documento pode ser removido mesmo de uma base em estado de erro — descartando um ficheiro que falhou a análise sem uma eliminação e reconstrução completas. A análise de documentos — Somente Texto, MinerU, Docling, Tika, markitdown, PyMuPDF4LLM ou LiteParse — e um modelo opcional de descrição de imagens são escolhidos em Settings → Knowledge & documents, com downloads de modelos locais desativados por predefinição. O Docling também pode correr em modo remoto contra um servidor Docling Serve (sem necessidade de instalação local nem de modelos), configurado nessa página (mode=remote, um URL base do servidor e uma chave API opcional) ou das variáveis de ambiente DOCLING_MODE / DOCLING_API_BASE_URL / DOCLING_API_TOKEN. O Tika é apenas remoto e aponta para o servidor Apache Tika configurado nessa página. A CLI espelha o ciclo de vida com list/info/create/connect-kiwix/add/search/eval/eval-diff/set-default/delete, comandos para adicionar ou remover fontes, list-sources e sync.

O motor LightRAG integrado é instalado com pip install 'deeptutor[rag-lightrag]'. Esse extra contém o SDK LightRAG suportado, mas não instala o MinerU. Escolha o MinerU de forma independente em Document Parsing e configure o seu modo cloud ou instale a sua CLI local atual quando quiser análise estruturada. O MinerU aceita PDF, imagens raster comuns, DOCX, PPTX e XLSX; o comando legado magic-pdf continua limitado a PDF. O motor Somente Texto e os restantes motores de análise não requerem o MinerU.

As consultas nativas do LightRAG e a indexação incremental exigem a configuração de embedding registada pelo índice publicado, incluindo o modelo, a dimensão e a identidade do endpoint. Se esta mudar, restaure a configuração original ou reconstrua com o embedding atual; os índices sem uma identidade de embedding registada exigem uma reconstrução. As vistas de detalhe da base de conhecimento e de versão do índice mostram orientações de recuperação, enquanto os ficheiros permanecem disponíveis para visualização e download.

Avaliar uma base de conhecimento. Com vários motores disponíveis, «qual recupera melhor aqui?» é uma pergunta empírica — e deeptutor kb eval responde-lhe. Escreva um conjunto de perguntas e respostas (um objeto JSON por linha: uma query e os trechos gold que uma recuperação ideal deveria devolver) e avalie a KB com deeptutor kb eval <name> --dataset qa.jsonl --top-k 5 [--mode hybrid] [--save baseline.json]. Cada caso é recuperado pelo mesmo caminho usado num turno de chat; as suas citações ordenadas são comparadas com os trechos de referência por texto exato ou sobreposição lexical (os limiares são ajustáveis com --min-ratio; a equivalência semântica não é avaliada), e a execução apresenta Recall@k / Precision@k / nDCG@k / MRR / MAP / Hit@k. As métricas são funções puras sobre a ordenação; nenhum modelo julga o resultado. Compare os relatórios guardados com deeptutor kb eval-diff baseline.json candidate.json para ver as alterações por métrica e por caso. Use --rewrite off ou --rewrite standalone em kb eval para comparar as consultas originais e reescritas; os relatórios conservam a proveniência da reescrita. Os casos em que a pesquisa falhou (índice em falta, credenciais incorretas) não recebem pontuação e são reportados separadamente, em vez de baixar as médias. O PageIndex usa raciocínio para a recuperação e não devolve chunks ordenados, pelo que fica excluído.

{"query": "Why do transformers scale attention?", "gold": ["Scaling keeps the dot products from growing with the dimension."]}
🌐 Recursos e Personalização — Materiais e Apoio Reutilizável
Recursos no workspace ativo

Os Recursos agrupam o Histórico de chat, os Favoritos com registos transferíveis e exportação em Markdown, o Diário de aprendizagem, o Centro de Conhecimento e um banco de questões com respostas e explicações. Inicie Prática a partir de uma seleção do banco de questões ou de Aprendizagem → Prática para sessões de revisão, acompanhamento de erros e repetição programada. A página separada Personalização contém personas, skills (playbooks SKILL.md), Serviços MCP de um clique e Aplicações CLI do catálogo CLI-Anything, cada uma com um guia de utilização a pedido. A Aprendizagem agrupa livros, percursos de domínio, coleções de leitura e as respetivas conversas de tutoria; cada recurso é oferecido apenas nos fluxos de trabalho que o suportam.

Biblioteca de skills de personalização

Não tem de escrever cada skill você mesmo — Importar do EduHub navega no catálogo da comunidade e descarrega uma skill diretamente para a sua biblioteca através de uma porta de segurança (veja Ecossistema).

🧠 Memória — Personalização Inspecionável
Visão geral da memória DeepTutor

A Memória é um sistema de três camadas suportado por ficheiros que pode ler, curar e auditar — deliberadamente não um armazém de vetores oculto. L1 é o espelho do espaço de trabalho mais um rasto de eventos append-only (trace/<surface>/<date>.jsonl); L2 são factos curados por superfície (L2/<surface>.md) com referências a entidades L1; L3 é a síntese entre superfícies (L3/<profile|recent|scope|preferences>.md) que regista as superfícies L2 contribuintes.

Gráfico de memória de três camadas DeepTutor

O Memory Graph mostra toda a pirâmide — síntese L3 no centro, L2 no anel do meio, rastreamentos L1 no exterior — com arestas de evidência L2 → L1 exatas e ligações L3 → superfícies contribuintes. A memória é rastreada nas superfícies chat, notebook, quiz, kb, book, partner e cowriter; os orçamentos de Atualização / Auditoria / Deduplicação do consolidador são ajustados em Settings → Memory.

⚙️ Configurações — Um Plano de Controlo
Navegador de configurações

Configurações é o plano de controlo operacional e abre em Geral, com o idioma da interface e o de saída do modelo. O navegador pesquisável liga a páginas independentes: Pessoal inclui Workspaces, Migração de dados, Aparência e Estatísticas de utilização; Aprendizagem e conversa inclui pontos de partida, anexos, Video Learning, controlos de alunos e responsáveis, Progresso de aprendizagem e Memory; Modelos e serviços inclui Provedores, Modelos de linguagem, Modelos de tarefa, Embedding, Search, Voz e Geração multimodal; Funcionalidades e integrações inclui ferramentas, parâmetros de capacidades, Partners e agentes e Conhecimento e documentos. Sistema reúne Rede, Estado de execução e Sobre; Conversas arquivadas permite pesquisar, restaurar ou eliminar permanentemente conversas arquivadas. Estado de execução contém a saúde do backend, memória residente e a matriz de Prontidão, que classifica bloqueios, avisos e sugestões das capacidades. Workspaces mantém os ficheiros dos temas e o estado de aprendizagem separados, com migração e exportação verificadas em Migração de dados. Um provedor guarda o endereço e a credencial de um fornecedor para reutilização pelos seus modelos de serviço; as páginas de modelos selecionam provedores guardados e configuram nomes e capacidades dos modelos. Os modelos de tarefa fixam um modelo pequeno e rápido para trabalho em segundo plano — nomear conversas e escrever pontos de partida — e usam a predefinição ativa quando deixados em branco. Voz agrupa síntese e transcrição de voz; Geração multimodal agrupa modelos de imagem e vídeo. Partners e agentes configura harnesses locais e um gateway Hermes remoto.

Voz Xiaomi MiMo. Adicione um provedor Xiaomi MiMo com https://api.xiaomimimo.com/v1 e a sua chave API; depois adicione mimo-v2.5-tts em Settings → Voz. Escolha uma voz predefinida como mimo_default, 冰糖 ou 苏打, use saída wav ou pcm16 e experimente-a antes de aplicar. As instruções de voz controlam o estilo e a velocidade da fala. Este adaptador suporta apenas vozes predefinidas; o design e a clonagem de voz exigem modelos separados e não são suportados. Se um modelo de voz MiMo anterior tiver sido configurado através do adaptador genérico compatível com OpenAI, recrie a respetiva entrada de voz usando o provedor Xiaomi MiMo, para que utilize o protocolo chat-completions. Consulte o guia oficial de voz MiMo.

Voz MiniMax — em Settings → Voz, escolha MiniMax para síntese de voz e selecione speech-2.8-hd. Configure uma chave API MiniMax e selecione explicitamente uma voz do sistema ou introduza um ID de voz personalizado. A base da API é https://api.minimax.io/v1 por predefinição; para a região da China, use https://api.minimaxi.com/v1. A leitura em voz alta e as pré-visualizações de voz usam o endpoint de voz nativo, com saída MP3, WAV, FLAC ou PCM e controlos de taxa de amostragem, velocidade e idioma. Consulte a API de voz MiniMax para IDs de voz e disponibilidade por conta.

Video Learning em Settings → Aprendizagem e conversa configura as legendas do YouTube e o acesso ao Invidious para Reading. Para usar o Invidious, defina a origem da API do backend gerida pelo administrador (por exemplo, http://127.0.0.1:3000) e a origem pública acessível pelo navegador, teste a ligação, selecione Invidious e guarde. Browse Invidious no diálogo para adicionar materiais do Reading pesquisa vídeos e acede às subscrições e listas de reprodução conectadas. A reprodução do YouTube usa o leitor oficial com privacidade melhorada; a ausência de legendas permanece visível e limita as evidências do tutor sem bloquear a reprodução nativa. Num checkout do código-fonte, execute python scripts/install_extras.py video-learning para o carregador predefinido de legendas do YouTube. Os links existentes de Watching migram para Reading, preservando o histórico de conversas, transcrições compatíveis, notas e progresso; as novas notas com marcas temporais são anotações do Reading. O Bilibili usa o seu próprio caminho de reprodução e legendas.

Configurações de aparência e temas DeepTutor

A maioria das secções usa um fluxo de rascunho e aplicação, para que possa testar um provedor antes de o confirmar. Também pode simplesmente pedir no Chat: o assistente lê a configuração atual, aplica uma alteração e diz se é necessário reiniciar ou reindexar — testando um novo modelo antes de o confirmar, para que nunca possa mudar-se sozinho para algo inacessível. As chaves API nunca passam pelo modelo, que em vez disso abre o formulário correspondente para si. Quatro temas incluídos — Default, Cream, Dark e Glass. Os ficheiros .env da raiz do projeto são intencionalmente ignorados; a configuração de runtime vive sob data/user/settings/*.json a menos que DEEPTUTOR_HOME ou deeptutor start --home aponte a aplicação para outro lugar.

OpenAI Codex OAuth (experimental). Adicionar OpenAI Codex em Settings → Provedores abre um login no navegador que corre contra o seu próprio plano ChatGPT, pelo que não é necessária nenhuma OPENAI_API_KEY. Os tokens vivem apenas em data/system/user-secrets/<owner>/private/openai-codex/ — na implementação multi-contentor com Compose, fora de qualquer árvore que o sandbox de execução possa alcançar — e o DeepTutor nunca lê nem modifica o seu login CLI ~/.codex. A lista de modelos vem do catálogo ao vivo dessa conta; iniciar sessão publica o perfil mas só se torna o modelo ativo quando ainda não há nenhum LLM configurado. Como um token autoriza o plano de uma pessoa, o perfil não é partilhável através de concessões de utilizador — cada conta inicia sessão por si própria, incluindo utilizadores comuns: o seu cartão de início de sessão está em Provedores, e os modelos, o catálogo e o logout resultantes permanecem privados dessa conta.

No início de sessão e em Refresh models, o DeepTutor lê a última versão estável de @openai/codex do registo npm oficial e usa-a como o client_version do pedido de catálogo. Isto é apenas metadados: não instala, descarrega nem atualiza a CLI Codex, e o pedido npm não transporta credenciais OAuth. A descoberta tem um limite de três segundos e um limite de resposta de 64 KiB. Se falhar, o DeepTutor usa a última versão bem-sucedida para essa conta, ou o seu fallback incorporado quando nenhuma estiver em cache. Apenas um catálogo ao vivo analisado com sucesso guarda uma nova versão; os validadores nunca são reutilizados entre versões ou entre gerações de credenciais. Uma rejeição de versão ou uma estrutura de catálogo incompatível permite uma repetição com a versão anterior; falhas de autenticação, de limite de taxa e de TLS não são repetidas como problemas de versão. Uma atualização manual falhada reporta um erro em vez de apresentar um catálogo antigo em cache como atualizado.

O histórico de versões bem-sucedido sobrevive à renovação de token da mesma conta e a erros de autenticação do catálogo, sem tornar novamente utilizáveis dados de modelo ou ETags invalidados. Terminar sessão limpa a cache local dessa conta, incluindo o histórico de versões. As leituras de estado normais e a inferência não consultam o npm. Novas entradas do catálogo não substituem um modelo já selecionado nem reiniciam sessões de aprendizagem em curso; aparecer no catálogo não estabelece compatibilidade total do protocolo de inferência. Não existe um atualizador de versão em segundo plano nem uma definição de versão pelo utilizador.

As implementações locais predefinidas com Docker e Podman usam redes loopback separadas e precisam de uma ponte temporária durante o início de sessão. Siga o guia da ponte OAuth temporária local do Codex para os comandos exatos de Docker, Compose, Podman e desmontagem.

Para uma implementação remota, o localhost do navegador e o localhost do servidor são máquinas diferentes, pelo que um proxy inverso comum sozinho não consegue transportar o callback localhost do navegador até ao servidor. Use um túnel SSH como ponte de callback. O túnel alcança a porta Web já publicada; o Next.js reencaminha apenas o caminho exato de callback para o broker de callback público, e o broker valida state antes de encaminhar para a operação OAuth original. O listener de callback permanece no loopback do backend, as portas 1455 e 1457 não são publicadas, e este caminho suporta a rede bridge predefinida do Docker.

ssh -N -L 1455:127.0.0.1:3782 <ssh-user>@<server-host>

Se o DeepTutor reportar a porta de callback de reserva 1457, use:

ssh -N -L 1457:127.0.0.1:3782 <ssh-user>@<server-host>

Execute apenas o comando que corresponde à porta de callback real; nunca execute ambos. 3782 é apenas a porta Web de exemplo: é a porta de frontend/contentor configurada, reportada como callback_forward_port. Esse valor não garante que a mesma porta esteja à escuta no 127.0.0.1 do host SSH. Se o Docker ou o Podman publicarem uma porta de host diferente, ou um proxy inverso escutar numa porta diferente, substitua apenas a porta de destino do lado direito (3782 acima) pela porta Web que realmente está à escuta no 127.0.0.1 do host SSH; mantenha a porta de callback do lado esquerdo como 1455 ou 1457. <server-host> é o host SSH cujo loopback possui essa porta à escuta. Se o URL do navegador nomear um proxy inverso ou balanceador de carga, substitua-o pelo host frontend SSH correto.

A CLI imprime o comando do túnel e depois tenta imediatamente abrir o navegador. Numa implementação remota, mantenha a página de autorização aberta sem a concluir, estabeleça o túnel impresso noutro terminal, e só depois continue a autorização.

A deteção de topologia remota tem um limite de localhost. Se o próprio Web for alcançado através de um encaminhamento localhost SSH ou de IDE, o navegador não consegue saber que o servidor é remoto. Para a operação Web atual, deixe a sua página de autorização por concluir, leia redirect_uri no URL de autorização dessa operação para identificar a porta de callback 1455 ou 1457, e crie o segundo túnel a partir dessa porta local para a porta Web real. Em alternativa, cancele essa operação Web e inicie uma nova com a CLI; a saída da CLI pertence à nova operação e não deve ser usada para a operação Web existente. Erros de quota e falhas de catálogo são reportados tal como ocorrem e nunca recorrem a um provedor pago. Este caminho de compatibilidade é experimental: a interface upstream pode mudar.

👥 Multi-Utilizador — Implementações Partilhadas · autenticação opcional, espaços de trabalho isolados por utilizador

A autenticação está desativada por predefinição — o DeepTutor corre em modo de utilizador único. Ative-a e uma árvore data/ aloja um espaço de trabalho de administrador, espaços de trabalho por utilizador isolados e espaços de trabalho de partners lado a lado:

data/
├── user/                    # Admin workspace + global settings
├── users/<uid>/             # Per-user scope: chat history, memory, notebooks, KBs
├── partners/<id>/workspace/ # Partner (synthetic-user) scope
├── cli-apps/                # Installed CLI apps, mounted read-only into the sandbox
└── system/                  # auth · grants · audit · user-secrets/<owner> (OAuth tokens)

O primeiro utilizador registado torna-se administrador e possui catálogos de modelos, credenciais de provedores, bases de conhecimento partilhadas, skills, livros partilhados canónicos e concessões por utilizador. Os utilizadores locais criados pelo administrador podem ser Standard, Learner ou Custom. Learner bloqueia as capacidades de aprendizagem e a política de materiais, acrescenta um perfil adaptativo e suporta credenciais de dispositivo revogáveis com validade e limites diários; Guardians autorizados podem consultar relatórios, aprovar materiais e repor credenciais. Os restantes utilizadores recebem espaços de trabalho isolados e modelos, KBs, skills, Partners e acesso a livros partilhados com âmbito, sem receber chaves API brutas. Se auth.json já contiver um username + password_hash, essa conta é o administrador: /register permanece fechado e as contas criadas em /admin/users são sempre role=user até serem promovidas.

Ativar: ligue a autenticação em data/user/settings/auth.json, reinicie deeptutor start, registe o primeiro administrador em /register, depois adicione utilizadores em /admin/users e atribua modelos, KBs, skills, Partners, política de ferramentas/MCP/aplicações CLI e acesso de execução de código através de concessões; configure os livros partilhados no painel Book access de cada utilizador.

Para origens privadas/públicas separadas, defina auth.private_login_hosts (ou AUTH_PRIVATE_LOGIN_HOSTS) para os hosts de frontend privados que podem mostrar o início de sessão por palavra-passe e o registo. O frontend reencaminha o Host HTTP recebido para o backend como a sua afirmação de host de frontend. Preserve o Host do navegador através do seu proxy inverso, e faça com que o ingress público recuse pedidos que indiquem um host privado; não exponha uma porta Next.js em bruto que aceite valores de Host arbitrários. O Host HTTP pode ser falsificado por um cliente direto, por isso a autorização de host privado depende dessa fronteira de ingress. O backend aceita afirmações de host de frontend apenas a partir do loopback por predefinição. Se o frontend Web se ligar a partir de outro contentor ou host, defina AUTH_TRUSTED_FRONTEND_PROXY_IPS para o endereço IP exato desse proxy de frontend no processo do backend (separado por vírgulas para mais de um). Isto substitui as predefinições; inclua 127.0.0.1,::1 se também forem necessárias ligações locais do frontend. Mantenha a API do backend privada para o proxy de frontend e não inclua redes de clientes gerais nesta lista. Quando private_login_hosts não está vazio, um utilizador autenticado numa origem privada pode abrir Profile → Public device sign-in e criar uma ligação de emparelhamento de curta duração e vinculada ao host para uma origem pública HTTPS. A página pública /handoff troca o código único por um bilhete JWE igualmente de curta duração num corpo POST, consome o bilhete uma vez e recebe o cookie de sessão HttpOnly normal.

O PocketBase continua a ser uma integração de utilizador único — mantenha integrations.pocketbase_url em branco para implementações multi-utilizador a menos que tenha ligado um armazém de utilizadores externo.

⌨️ DeepTutor CLI — Interface Nativa de Agentes

Um binário deeptutor, duas formas de entrada: um REPL interativo para pessoas que vivem no terminal, e JSON estruturado para outros agentes que conduzem o DeepTutor como uma ferramenta. As mesmas capacidades, ferramentas e bases de conhecimento de qualquer forma.

Conduzir você mesmo

deeptutor chat abre um REPL interativo e seleciona um modo com --capability; deeptutor run <capability> "<message>" recebe essa capacidade como primeiro argumento posicional e sai após um turno. Ambos aceitam --tool, --kb, --config e --workspace para selecionar um workspace registado.

deeptutor chat                                              # interactive REPL
deeptutor chat --capability deep_solve --kb my-kb
deeptutor run chat "Explain the Fourier transform" --kb textbook
deeptutor run chat "Find recent work beyond this material" --kb textbook
deeptutor run deep_research "Survey 2026 papers on RAG" \
  --config mode=report --config depth=standard

--kb fornece contexto para as ferramentas automáticas de RAG e Knowledge Frontier; o Frontier requer os módulos de conhecimento e pesquisa. --tool seleciona as ferramentas ativáveis pelo utilizador. Os módulos ativados também fornecem comandos para bases de conhecimento, sessões, partners, skills, notebooks, memória e configuração.

Deixar um agente conduzir

O DeepTutor foi construído para ser operado por outro agente. Adicione --format json a qualquer run e cada turno transmite NDJSON — um evento por linha (content, tool_call, tool_result, done, …), cada linha marcada com o seu session_id. As execuções são seguras sem TTY: uma pausa ask_user sem TTY resolve-se automaticamente com uma resposta vazia em vez de bloquear.

# One shot, machine-readable
deeptutor run deep_solve "Find d/dx[sin(x^2)]" --tool reason --format json

# Chain turns in one stateful session — capture the id, reuse it
SID=$(deeptutor run deep_research "Survey 2026 papers on RAG" \
  --config mode=report --config depth=standard --format json \
  | jq -r 'select(.type=="done").session_id')
deeptutor run deep_question "Quiz me on that survey" --session "$SID" --format json

O repositório inclui um SKILL.md na raiz — um documento compacto de orientação para a CLI. Peça ao seu agente para o ler explicitamente; o respetivo guia de configuração por agentes cobre a instalação e a configuração. Também pode envolver deeptutor run como uma ferramenta num loop LangChain / AutoGen. Receitas completas: Agent Handoff.

Referência de comandos

A tabela cobre a instalação completa e os complementos opcionais; os comandos e as capacidades requerem que os respetivos módulos estejam ativados. O núcleo fornece chat e ask_questions.

Comando Descrição
deeptutor init [--non-interactive] [--home PATH] Executar o assistente de configuração ou criar as predefinições em falta sem perguntas
deeptutor doctor [--online] Verificar se o runtime está pronto para iniciar uma sessão; --online também sonda o provedor de modelo configurado, --format json imprime o relatório
deeptutor start [--home PATH] [--dev] [--detach] [--no-browser] Lançar backend + frontend juntos, opcionalmente desconectado ou sem abrir o navegador
deeptutor stop [--home PATH] Parar um launcher iniciado com --detach
deeptutor serve [--port PORT] Iniciar apenas o backend FastAPI
deeptutor module list/install/uninstall/enable/disable Inspecionar e alterar módulos com o DeepTutor parado; os checkouts de código-fonte suportam ativar/desativar
deeptutor workspace show/set/reset Inspecionar, selecionar ou repor o Content Workspace por utilizador
deeptutor run <capability> <message> Executar um turno de capacidade único (chat, ask_questions, deep_solve, deep_question, deep_research, visualize, math_animator, video_lesson, mastery_path, immersive_reading, audio_overview); adicionar --format json para saída NDJSON
deeptutor chat REPL interativo com controlos de capacidade, ferramenta, KB, notebook e histórico
deeptutor partner list/create/start/stop Gerir partners ligados por IM
deeptutor kb list/info/create/connect-kiwix/add/search/eval/eval-diff/set-default/delete/list-sources/sync Gerir bases de conhecimento, conectar arquivos Kiwix, avaliar e comparar execuções de recuperação e sincronizar fontes GitHub/web registadas (com comandos para adicionar ou remover fontes)
deeptutor skill search/install/list/remove/login/logout/publish/update Gerir habilidades, instalar de hubs e publicar as suas (eduhub:<slug> por padrão, veja Ecossistema)
deeptutor memory show/clear Inspecionar documentos de memória L2/L3 ou limpar memória L1/toda
deeptutor session list/show/open/rename/delete Gerir sessões partilhadas
deeptutor notebook list/create/show/add-md/replace-md/remove-record Gerir notebooks a partir de ficheiros Markdown
deeptutor book list/health/refresh-fingerprints Inspecionar livros e atualizar impressões digitais de fontes
deeptutor plugin list/info/state/search/show/install/approve/enable/disable/rollback/uninstall Inspecionar ferramentas e capacidades; gerir pacotes de plugins revistos e as respetivas aprovações de permissões
deeptutor config show [--home PATH] Mostrar a configuração de runtime resolvida com credenciais ocultadas
deeptutor config providers Listar provedores de configuração suportados e predefinições em JSON
deeptutor config apply FILE [--check] [--home PATH] Aplicar JSON de configuração sem perguntas ou validá-lo sem escrever definições
deeptutor provider login <provider> Autenticação de provedor (openai-codex login OAuth; github-copilot login por dispositivo do GitHub; codebuddy valida a autenticação do SDK CodeBuddy e inicia o login quando necessário)

As credenciais do GitHub Copilot pertencem ao proprietário do DeepTutor com sessão iniciada e ficam apenas em <runtime-home>/data/system/user-secrets/<owner-id>/private/github-copilot/credentials.v1.json, fora dos workspaces da sandbox. Os partners da CLI/do administrador usam as credenciais do administrador; os outros utilizadores iniciam sessão separadamente, e os perfis Copilot não podem ser partilhados através de concessões de modelos. Os ficheiros de tokens externos do nanobot/Copilot nunca são importados: após a atualização, execute deeptutor provider login github-copilot novamente.

O login valida a inferência com um modelo descoberto no momento; init valida o modelo selecionado e aborta em caso de falha sem guardar o rascunho de configuração. A autenticação bem-sucedida no GitHub por si só não comprova acesso aos modelos Copilot (o login guardado é mantido se a validação falhar). Os pedidos de runtime seguem o endpoint da API devolvido pela troca de tokens, incluindo nas atualizações, e respeitam os metadados de endpoint Responses/Chat Completions de cada modelo.

A compatibilidade Responses específica do Copilot é aplicada no envio sem reescrever o histórico guardado.

Distribuição de apenas CLI

O wheel do núcleo fornece a CLI e o SDK; deeptutor-cli é um metapacote de compatibilidade. O código-fonte disponibiliza todos os módulos presentes no repositório, pelo que deve instalar as respetivas dependências Python e dispensar a configuração do frontend para usar a CLI:

python -m pip install -r requirements/full.txt
python -m pip install -e . --no-deps

Para uma instalação mínima, use o wheel do núcleo. As distribuições opcionais acrescentam ferramentas, capacidades, rotas de API, serviços em segundo plano e navegação. Os módulos partilham um ambiente Python e têm de corresponder à versão do núcleo. deeptutor[full] seleciona os módulos comuns da aplicação na instalação; as funcionalidades individuais podem ser removidas mais tarde.

Pare o DeepTutor (Ctrl+C no respetivo terminal) e use o mesmo ambiente Python e o mesmo DEEPTUTOR_HOME:

deeptutor module list                       # installed / enabled / ready
deeptutor module disable research           # hide and deactivate; keep code
deeptutor module enable research            # restore it and required modules

# Package installations only; source checkouts use enable / disable:
deeptutor module install solve              # install the matching module and dependencies
deeptutor module uninstall solve --dry-run  # inspect the plan and dependency blockers
deeptutor module uninstall solve            # remove only this module's distribution
deeptutor chat                              # restart the CLI; use start for an installed Web app

Exemplos: solve, research, questions, knowledge, parsing, reading, mastery, books, memory, notebook e partners. Os módulos dependentes bloqueiam a remoção; o núcleo não pode ser removido através do comando de módulos. Desativar ou desinstalar preserva as definições, conversas, bases de conhecimento e ficheiros gerados. As dependências de terceiros partilhadas são mantidas.

No navegador: Settings → Runtime status → Modules mostra o estado dos módulos e os comandos de terminal correspondentes. As alterações de pacotes exigem um ambiente parado e são efetuadas na CLI. Chat → Personalizar página e Aprendizagem → Nova aprendizagem → Personalizar página alteram imediatamente as escolhas pessoais de página; ocultar uma entrada não desinstala o respetivo módulo nem revoga o acesso.

A família de pacotes 1.7.0 usa versões correspondentes no núcleo e nos wheels de funcionalidades. Para instalar wheels locais, passe --wheelhouse /path/to/wheels a module install. Consulte instalação de módulos e desenvolvimento a partir do código-fonte para compilar os wheels e conhecer os detalhes de implementação.

🧩 Ecossistema — EduHub e a Comunidade de Skills

As skills do DeepTutor usam o formato aberto Agent-Skills — uma pasta com um playbook SKILL.md (frontmatter YAML + Markdown) e ficheiros de referência opcionais. Nada nisto é específico do DeepTutor, por isso qualquer registo que fale o formato torna-se uma fonte para a sua biblioteca. O DeepTutor inclui o EduHub — o nosso próprio registo de skills focado em educação — como hub padrão.

EduHub — o ecossistema de habilidades do DeepTutor

EduHub é o hub da comunidade que o DeepTutor lançou para partilhar skills de agentes orientadas para o ensino — tutores socráticos, construtores de cartões flash, feedback de redações, planos de exames, explicadores de conceitos e muito mais. Está integrado no DeepTutor, por isso não há nada a configurar: um slug simples ou um prefixo eduhub: resolve para ele.

Encontrar e instalar — no navegador, abra Espaço de Aprendizado → Skills → Importar do EduHub para navegar no catálogo e descarregar uma skill diretamente para a sua biblioteca. Do terminal:

deeptutor skill search "socratic tutor"               # search EduHub (the default hub)
deeptutor skill install socratic-tutor                # fetch → verify → register
deeptutor skill install eduhub:[email protected]   # pin a hub and a version
deeptutor skill list                                  # local skills with their hub provenance

Publicar a sua própria — empacote um SKILL.md e partilhe-o de volta com a comunidade:

deeptutor skill login                                 # browser sign-in to EduHub
deeptutor skill publish ./my-skill                    # interactive: pick a track + tags, then upload
deeptutor skill update                                # roll back or release a new version

O EduHub também é um registo independente compatível com ClawHub, por isso agentes que não são o DeepTutor (Claude Code, Codex, …) podem usá-lo diretamente através da CLI eduhub — npx eduhub install socratic-tutor.

A porta de segurança de importação

Seja qual for a fonte, cada importação passa pela mesma porta de segurança antes de qualquer coisa tocar no seu espaço de trabalho:

  • o veredicto de segurança do registo é verificado primeiro — os pacotes sinalizados são recusados a menos que passe --allow-unverified;
  • os arquivos são extraídos defensivamente com verificações de travessia de caminhos, número de entradas, tamanho, taxa de compressão, sufixo e links simbólicos; os bits executáveis são removidos, enquanto ficheiros sem extensão continuam a ser permitidos;
  • o frontmatter é normalizado para o esquema do DeepTutor e always: é removido, por isso uma skill descarregada nunca pode forçar-se em cada prompt do sistema;
  • a proveniência — hub, versão, veredicto e hora de instalação — é escrita em .hub-lock.json para auditorias e atualizações.

Em implementações multi-utilizador, as importações pelo navegador chegam à camada de skills do chamador autenticado, enquanto as instalações pela CLI e pela consola de administração têm como alvo o espaço de trabalho do proprietário/administrador; as skills do administrador permanecem ocultas e em modo somente leitura para utilizadores comuns até serem atribuídas.

Também compatível com ClawHub

Como o DeepTutor fala o formato aberto Agent-Skills, o ClawHub também funciona como fonte de primeira classe — está integrado juntamente com o EduHub. Escolha-o com o prefixo de hub:

deeptutor skill search "git release notes" --hub clawhub
deeptutor skill install clawhub:[email protected]
deeptutor skill install clawhub:udiedrichsen/stock-analysis

Quando vários publicadores partilham o mesmo slug, a pesquisa mostra cada publicador e uma referência de instalação totalmente qualificada (clawhub:<ownerHandle>/<slug>).

Adicione mais registos em data/user/settings/skill_hubs.json: uma entrada type: "clawhub" aponta para qualquer API HTTP compatível (EduHub e ClawHub falam ambos), type: "command" envolve qualquer CLI de busca que um registo forneça, e "default" escolhe o hub usado para slugs simples. Todos eles alimentam a mesma porta de importação.

🤝 Parceiros de Código Aberto

PageIndex

Usando o código: DEEPTUTOR20 — obtenha $20 de desconto na sua primeira subscrição PageIndex!

🌐 Comunidade

🔗 Mantenedores

Bingxi Zhao
Bingxi Zhao
Xingyu Hou
Xingyu Hou
Jiahao Zhang
Jiahao Zhang

📮 Contacto

O DeepTutor é um projeto de código aberto liderado por Bingxi Zhao dentro do Grupo HKUDS, e itera numa forma totalmente de código aberto, construído em conjunto com a comunidade. Até agora, NÃO temos produtos online pagos de qualquer forma. Sinta-se à vontade para contactar em [email protected] para discussões, ideias ou colaboração.

🙏 Agradecimentos

Um agradecimento sincero a Chao Huang, diretor do Data Intelligence Lab @ HKU, e aos nossos colegas do HKUDS pelo seu caloroso apoio — especialmente Jiahao Zhang, Zirui Guo e Xubin Ren. Também somos profundamente gratos à comunidade de código aberto: as suas estrelas, issues, pull requests e discussões moldam o DeepTutor todos os dias.

O DeepTutor também assenta nos ombros de projetos de código aberto excepcionais que nos deram tanto ferramentas como inspiração:

Projeto Papel / Inspiração
LlamaIndex Espinha dorsal da pipeline RAG e indexação de documentos
nanobot Motor de agente ultraligeiro que alimentou o TutorBot original (HKUDS)
LightRAG RAG Simples e Rápido (HKUDS)
AutoAgent Framework de Agentes Sem Código (HKUDS)
AI-Researcher Pipeline de investigação automatizada (HKUDS)
OpenClaw Gateway aberto de agentes e ecossistema de skills por trás do ClawHub
Codex CLI de programação nativa de agentes que inspirou o nosso fluxo de trabalho CLI
Claude Code CLI de programação agêntica que inspirou o loop de agente do DeepTutor
ManimCat Geração de animações matemáticas impulsionada por IA para o Math Animator

🗺️ Roadmap & Contribuir

Queremos que o DeepTutor continue a iterar e a melhorar — e, em última análise, a tornar-se um presente que devolvemos à comunidade de código aberto. O nosso roadmap é atualizado continuamente; vote em itens lá ou proponha novos. Se quiser contribuir, veja o Guia de Contribuição para a estratégia de branches, padrões de código e como começar.

Esperamos que o DeepTutor se torne um presente para a comunidade. 🎁

Contribuidores

Classificação do histórico de estrelas

Licenciado sob Apache License 2.0.

Visualizações