An AI assistant with hybrid RAG, a native context graph, and a full development workbench including terminal, git, and filesystem access.
Also known as brunosrz/vectora, vectora-agent
- Stars
- 1
- Tools
- —
- Downloads, 30 days
- 122
- Latest version
- 0.1.0rc3
- Last commit
- Nov 15, 2026
- License
- AGPL-3.0
What is Vectora MCP?
Vectora is an AI assistant with hybrid RAG, a native context graph, and a full development workbench including terminal, git, and filesystem access.
Summary generated from the project's README
About Vectora MCP server
Providing a self-hosted AI development workbench for engineering teams is what Vectora does. It functions as a shared environment where an agent and developers interact through a multi-user web chat and a comprehensive side panel. The system operates locally or on a server using SQLite and LanceDB for lite setups, or Postgres, Qdrant, and Redis for scaled production environments. Users connect their preferred LLM providers such as Google Gemini, OpenAI, Anthropic, or local Ollama instances, and require API keys for Cohere and Tavily to enable advanced retrieval and web search.
This assistant bridges the knowledge gap by combining hybrid RAG with a native Context Graph. While standard RAG uses BM25 and dense vectors with rerankers like VoyageAI, the Context Graph uses tree-sitter to map structural relationships between functions and classes across languages like Python, Rust, and Go. The workbench provides direct access to over 70 tools, including a real PTY terminal, git operations, and a filesystem editor, allowing the agent to act as a coder, search specialist, or orchestrator within your specific codebase.
What you can do with it
- 1Structural Code AnalysisAsk the agent to explain the relationships between complex classes and functions using the native knowledge graph.
- 2Hybrid Documentation RetrievalQuery your internal documentation using a combination of vector search and keyword matching for high precision.
Written from the project's README. Every use case is checked against a quote from it.
How to install Vectora MCP
Formats verified 10 Nov 2026Add to CursorAdd to GooseInstall Vectora MCP in Claude Code
$ claude mcp add --env 'COHERE_API_KEY=<YOUR_COHERE_API_KEY>' --env 'TAVILY_API_KEY=<YOUR_TAVILY_API_KEY>' --env 'ANTHROPIC_API_KEY=<YOUR_ANTHROPIC_API_KEY>' --env 'GOOGLE_API_KEY=<YOUR_GOOGLE_API_KEY>' --env 'LANGSMITH_API_KEY=<YOUR_LANGSMITH_API_KEY>' --env 'OPENAI_API_KEY=<YOUR_OPENAI_API_KEY>' vectora -- uvx vectora-agentInstall Vectora MCP in Cursor
~/.cursor/mcp.json
{
"mcpServers": {
"vectora": {
"command": "uvx",
"args": [
"vectora-agent"
],
"env": {
"COHERE_API_KEY": "<YOUR_COHERE_API_KEY>",
"TAVILY_API_KEY": "<YOUR_TAVILY_API_KEY>",
"ANTHROPIC_API_KEY": "<YOUR_ANTHROPIC_API_KEY>",
"GOOGLE_API_KEY": "<YOUR_GOOGLE_API_KEY>",
"LANGSMITH_API_KEY": "<YOUR_LANGSMITH_API_KEY>",
"OPENAI_API_KEY": "<YOUR_OPENAI_API_KEY>"
}
}
}
}Install Vectora MCP in VS Code
.vscode/mcp.json
{
"servers": {
"vectora": {
"type": "stdio",
"command": "uvx",
"args": [
"vectora-agent"
],
"env": {
"COHERE_API_KEY": "<YOUR_COHERE_API_KEY>",
"TAVILY_API_KEY": "<YOUR_TAVILY_API_KEY>",
"ANTHROPIC_API_KEY": "<YOUR_ANTHROPIC_API_KEY>",
"GOOGLE_API_KEY": "<YOUR_GOOGLE_API_KEY>",
"LANGSMITH_API_KEY": "<YOUR_LANGSMITH_API_KEY>",
"OPENAI_API_KEY": "<YOUR_OPENAI_API_KEY>"
}
}
}
}Install Vectora MCP in VS Code CLI
$ code --add-mcp '{"name":"vectora","type":"stdio","command":"uvx","args":["vectora-agent"],"env":{"COHERE_API_KEY":"<YOUR_COHERE_API_KEY>","TAVILY_API_KEY":"<YOUR_TAVILY_API_KEY>","ANTHROPIC_API_KEY":"<YOUR_ANTHROPIC_API_KEY>","GOOGLE_API_KEY":"<YOUR_GOOGLE_API_KEY>","LANGSMITH_API_KEY":"<YOUR_LANGSMITH_API_KEY>","OPENAI_API_KEY":"<YOUR_OPENAI_API_KEY>"}}'Install Vectora MCP in Claude Desktop
claude_desktop_config.json
{
"mcpServers": {
"vectora": {
"command": "uvx",
"args": [
"vectora-agent"
],
"env": {
"COHERE_API_KEY": "<YOUR_COHERE_API_KEY>",
"TAVILY_API_KEY": "<YOUR_TAVILY_API_KEY>",
"ANTHROPIC_API_KEY": "<YOUR_ANTHROPIC_API_KEY>",
"GOOGLE_API_KEY": "<YOUR_GOOGLE_API_KEY>",
"LANGSMITH_API_KEY": "<YOUR_LANGSMITH_API_KEY>",
"OPENAI_API_KEY": "<YOUR_OPENAI_API_KEY>"
}
}
}
}Install Vectora MCP in Codex
$ codex mcp add vectora --env 'COHERE_API_KEY=<YOUR_COHERE_API_KEY>' --env 'TAVILY_API_KEY=<YOUR_TAVILY_API_KEY>' --env 'ANTHROPIC_API_KEY=<YOUR_ANTHROPIC_API_KEY>' --env 'GOOGLE_API_KEY=<YOUR_GOOGLE_API_KEY>' --env 'LANGSMITH_API_KEY=<YOUR_LANGSMITH_API_KEY>' --env 'OPENAI_API_KEY=<YOUR_OPENAI_API_KEY>' -- uvx vectora-agentInstall Vectora MCP in Codex config.toml
~/.codex/config.toml
[mcp_servers.vectora] command = "uvx" args = ["vectora-agent"] [mcp_servers.vectora.env] COHERE_API_KEY = "<YOUR_COHERE_API_KEY>" TAVILY_API_KEY = "<YOUR_TAVILY_API_KEY>" ANTHROPIC_API_KEY = "<YOUR_ANTHROPIC_API_KEY>" GOOGLE_API_KEY = "<YOUR_GOOGLE_API_KEY>" LANGSMITH_API_KEY = "<YOUR_LANGSMITH_API_KEY>" OPENAI_API_KEY = "<YOUR_OPENAI_API_KEY>"
Install Vectora MCP in Gemini CLI
$ gemini mcp add -s user -e 'COHERE_API_KEY=<YOUR_COHERE_API_KEY>' -e 'TAVILY_API_KEY=<YOUR_TAVILY_API_KEY>' -e 'ANTHROPIC_API_KEY=<YOUR_ANTHROPIC_API_KEY>' -e 'GOOGLE_API_KEY=<YOUR_GOOGLE_API_KEY>' -e 'LANGSMITH_API_KEY=<YOUR_LANGSMITH_API_KEY>' -e 'OPENAI_API_KEY=<YOUR_OPENAI_API_KEY>' vectora uvx -- vectora-agentInstall Vectora MCP in Gemini settings.json
~/.gemini/settings.json
{
"mcpServers": {
"vectora": {
"command": "uvx",
"args": [
"vectora-agent"
],
"env": {
"COHERE_API_KEY": "<YOUR_COHERE_API_KEY>",
"TAVILY_API_KEY": "<YOUR_TAVILY_API_KEY>",
"ANTHROPIC_API_KEY": "<YOUR_ANTHROPIC_API_KEY>",
"GOOGLE_API_KEY": "<YOUR_GOOGLE_API_KEY>",
"LANGSMITH_API_KEY": "<YOUR_LANGSMITH_API_KEY>",
"OPENAI_API_KEY": "<YOUR_OPENAI_API_KEY>"
}
}
}
}Configuration
COHERE_API_KEYRequiredSecretCohere API key — required for RAG embeddings and reranking
TAVILY_API_KEYRequiredSecretTavily API key — required for web search and URL extraction
ANTHROPIC_API_KEYSecretAnthropic API key (optional — alternative LLM provider)
GOOGLE_API_KEYSecretGoogle Gemini API key (recommended free-tier LLM provider)
LANGSMITH_API_KEYSecretLangSmith API key (optional — tracing and observability)
OPENAI_API_KEYSecretOpenAI API key (optional — alternative LLM provider)
LLM_PROVIDERTELEMETRY_ENABLED
Automated checks
Ran Nov 13, 2026Full report →Passed our automated checks. That is not a security audit: read the code and give the server the narrowest access it needs. How checks work
- Source repository linked and reachablebrunosrz/vectora is public and reachablegithub.com/brunosrz/vectora ↗Pass
- Package names this repository as its sourceNot checked
- Build provenance (Sigstore attestation)Sigstore attestation for vectora-agentpypi.org/project/vectora-agent/ ↗Pass
- Open source license (OSI)AGPL-3.0spdx.org/licenses/AGPL-3.0.html ↗Pass
- Commit or release in the last yearLast commit or release 2026-11-12github.com/brunosrz/vectora ↗Pass
- OpenSSF ScorecardNot checked
- Package name not close to a popular packageNo popular package one edit away from vectora-agentPass
- No critical advisory in the package or its dependencies130 resolved dependencies checked; no critical advisoryosv.dev ↗Pass
- No hidden instructions to the model0 tool descriptions and the README read; no override phrases, credential paths or hidden charactersPass
- Destructive tools are labelledNot checked
- Remote endpoint answers the MCP handshakeNot checked
README
View on GitHubVectora
Vectora é um assistente de IA self-hosted para equipes de desenvolvimento — roda inteiramente no seu servidor, com um workbench completo (arquivos, git, terminal, RAG, Context Graph, browser) compartilhado entre você e o agente, e vem com um chat web multi-usuário.
No seu núcleo, o Vectora resolve o problema do abismo de conhecimento: os LLMs não conhecem sua base de código, sua documentação ou as versões mais recentes da sua stack. O Vectora preenche essa lacuna por dois caminhos complementares: RAG híbrido (BM25 + vetores densos + reranker Cohere/VoyageAI) para recuperação por similaridade, e o Context Graph — um grafo de conhecimento nativo do workspace (funções, classes, conceitos e suas relações, via tree-sitter + extração semântica por LLM) para contexto estrutural.
Por que o Vectora?
- Motor nativo — o loop de execução (
backend/engine/conversation_loop.py::run_conversation) é umwhileimperativo, não um grafo compilado. Isso dá HITL configurável por modo de permissão, backends de filesystem pluggable e um supervisor que delega para 2 subagentes especializados com instruções explícitas — sem hops de roteamento desnecessários. - Pipeline RAG híbrido — cada recuperação roda BM25 + busca vetorial densa + reranker antes de voltar para o supervisor sintetizar a resposta.
- Context Graph nativo — analisa o workspace (AST via tree-sitter para Python/JS/TS/Go/Rust/Java/C/C++, + extração semântica por LLM) e gera um grafo de conhecimento com god nodes, comunidades e perguntas sugeridas. Configurável por tipo de arquivo (ex.: só markdown, deixando o código para o RAG).
- 70+ ferramentas nativas — filesystem, git (14 operações), GitHub (
gh), terminal (PTY real), web, RAG, memória, integrações opcionais (Jira, Slack, Linear, Google Drive, Gmail, Notion) e utilitárias (hash, JWT, regex, HTTP) — sempre disponíveis, sem instalar plugins. - Resiliência de provider — fallback automático de LLM por quota (429 troca de provider sozinho, com aviso visível) e de embeddings/rerank (Cohere↔VoyageAI). O model selector reflete o provider ativo.
- Embeddings curados — resultados da busca web passam por um gate de curadoria (reranker + LLM judge) antes de serem indexados. Sua base de conhecimento nunca é contaminada.
- Chat web multi-usuário — interface React 19 (Vite + TanStack Router) com autenticação, RBAC, workspaces e a workbench (terminal, git, arquivos, context graph, memória, planos — ver abaixo).
- Memória persistente entre sessões — memória isolada por usuário, com checkpoint nativo (
SessionStore) por thread. - Infraestrutura zero no modo lite — SQLite + LanceDB. Sem Docker ou Postgres para uso local ou times pequenos. O modo complete (Postgres + Qdrant + Redis) já existe como caminho alternativo para quem precisa de mais escala.
- Multi-LLM — Google Gemini, OpenAI, Anthropic, Cohere, ou Ollama (totalmente local). O model selector lista apenas os providers com API key configurada.
Arquitetura
Supervisor + Subagentes (motor nativo)
O agente principal (backend/services/agent_factory.py) roda sobre o motor nativo (backend/engine/conversation_loop.py::run_conversation) — um loop while imperativo, não um grafo compilado. O supervisor responde direto para consultas simples ou delega, via a tool nativa delegate_to_subagent, para um dos 2 subagentes especializados:
| Agente | Papel | Ferramentas principais |
|---|---|---|
| orchestrator | Supervisor — responde direto OU delega para coder/search | create_artifact, save_memory, get_memory, delete_memory, RAG |
| coder | Filesystem, terminal, git — geração e revisão de código | file_read, file_edit, file_write, grep, list_dir, terminal, tools de git |
| search | Busca web em tempo real + RAG (não há subagente de RAG separado) | web_search, web_fetch, vector_search, embedding, ingest_docs |
HITL (Human-in-the-Loop) roda via should_require_approval (backend/engine/hitl.py), configurável por modo de permissão (perguntar sempre / aceitar edições / autônomo / plano).
Pipeline de RAG (dentro das tools search/rag)
| Score | Caminho |
|---|---|
| ≥ 0.7 | Injeção direta no contexto — alta confiança |
| 0.4–0.7 | Rerank (Cohere/VoyageAI) → injeção |
| < 0.4 | Cai para busca web, com os resultados curados (reranker + LLM judge) antes de indexar |
Workbench (painel lateral)
No modo Code, o chat vem com um painel lateral multi-aba — a workbench. Cada aba renderiza a partir de dados do backend em tempo real:
| Aba | O que faz |
|---|---|
| File System | Árvore do workspace; abre arquivos como janelas flutuantes (redimensionáveis, arrastáveis), edita via Monaco Editor, e fixa arquivos ("pin") para manter no contexto. |
| Git | Status (staged/unstaged/untracked), diff por arquivo com hunks, histórico de commits, stash e worktrees. |
| Search | Busca em todo o workspace (arquivos + conteúdo). |
| Plan | Planos, specs e guias gerados pelo agente (create_artifact, markdown em ~/.vectora/artifacts/). |
| Segundo plano | Tarefas em segundo plano da sessão + histórico de execuções. |
| Preview | Configura targets de run (servidor/comando) e mostra o preview do projeto. |
| Memory (RAG) | Memórias e citações RAG/web indexadas + settings de RAG: reranker on/off + top_k, provider de rerank/embedding (Cohere/Voyage/auto), tipos de arquivo a ingerir, e gestão de coleções (listar/apagar). |
| Context Graph | Constrói e exibe o grafo de conhecimento do workspace (god nodes, conexões, perguntas) + settings: tipos de arquivo a indexar (code/document/paper) e modo (semântico/AST). Build pausável e retomável por quota. |
| Terminal | Shell embarcado real via PTY (pywinpty/ptyprocess) renderizado com xterm.js, com tema dinâmico sincronizado ao tema da UI. |
Os artefatos do Context Graph e o cache ficam em .vectora/context-graph/ dentro do workspace; o que estiver no .vectoraignore (ignore unificado, vale para context graph, RAG, filesystem e chat) é invisível para o Vectora.
Pré-requisitos
| Requisito | Notas |
|---|---|
| Python 3.13 | Gerenciado pelo uv — fixado em 3.13 (Nuitka ainda não suporta 3.14) |
| Node.js 24+ | Para o frontend web (pnpm obrigatório) |
| Chave Cohere | Embeddings + reranking — plano gratuito |
| Chave Tavily | Busca web — plano gratuito |
| Provedor LLM | Google Gemini, OpenAI, Anthropic, Cohere, ou Ollama |
Início rápido (a partir do código fonte)
git clone https://github.com/vectora-company/vectora.git
cd vectora
# Instalar dependências Python
uv sync
# Copiar e preencher suas chaves de API
cp .env.example .env
# Edite o .env: GOOGLE_API_KEY, COHERE_API_KEY, TAVILY_API_KEY
# Instalar dependências do frontend (SPA Vite)
pnpm --dir frontend install
# Terminal 1 — backend completo + SPA (porta 8080)
uv run vectora start --port 8080
# Terminal 2 — frontend dev (Vite, porta 3000, faz proxy p/ a API)
pnpm --dir frontend dev
Abra http://localhost:3000. O primeiro usuário a se cadastrar vira administrador root.
CLI de operação (VPS via SSH)
O frontend cobre toda a configuração, mas em VPS via SSH a CLI Rich expõe o essencial:
uv run vectora config keys # wizard de API keys + provider de LLM
uv run vectora config docker up # sobe Postgres + Redis + Qdrant local
uv run vectora start --headless # backend sem Electron (modo servidor)
uv run vectora web # HTTP + Electron/Chromium, sem bandeja Python
Build (SCons)
O sistema de build usa SCons, incluído como dependência de dev, invocado a partir da raiz do repositório. Funciona direto no PowerShell, cmd, bash ou zsh — sem dependência de sintaxe shell específica.
Produto final (do zero ao instalador)
scons release Build completo + instalador nativo para o SO atual
Bump de versão, build dos instaladores e publicação no canal de update rodam
só via GitHub Actions, disparados por uma tag v* real (criada quando o
usuário mescla o PR de release acumulado que release-please.yml mantém
automaticamente) ou por workflow_dispatch manual.
Pipeline executado em sequência (encadeado automaticamente por release):
build frontend (Vite) --> build híbrido do backend --> Electron + electron-builder
frontend/dist/ dist/vectora/vectora(.exe) frontend/dist-electron/
O "build híbrido" (build-hybrid.py, chamado pelo scons) compila só o pacote backend/ em C via Nuitka --mode=package (gera backend.pyd) e depois usa PyInstaller para empacotar o launcher + backend.pyd + libs Python num único vectora.exe. Compilar só o backend (em vez de onefile puro) evita OOM ao compilar dependências gigantes (google.genai.types, LanceDB) para C. O pipeline de CI (GitHub Actions) ainda usa Nuitka onefile direto para as builds nativas de release — os dois caminhos convivem hoje.
Qualidade
scons tests Suíte completa: pytest tests/ (unit+integration+e2e+stress) + vitest
scons coverage Mesma suíte com relatório de cobertura
scons lint ruff + ty + bandit (Python) + tsc + oxlint (TypeScript)
scons tests-storage Só testes de storage (Postgres/Redis/Qdrant — sobe docker automaticamente)
scons clean Remove dist/ frontend/dist/ frontend/electron/dist*
scons help Lista completa com descrições
Nota: no Windows basta abrir o PowerShell ou cmd na raiz do repositório e rodar scons release. Sem Git bash, sem truques de shell.
CI/CD
- GitHub Actions (
.github/workflows/vectora.yml) — pipeline única: lint → security scan (bandit + pip-audit) → frontend (oxlint/tsc/vitest) → build verification → testes unit/stress/integration+e2e — sempre, em todo PR contramastere em todo push emmaster, sem gate manual. Só orelease-native(matriz Linux/macOS/Windows, build híbrido Nuitka + electron-builder) continua condicionado, agora numa tagv*real ouworkflow_dispatchmanual..github/workflows/pr-checks.ymlroda em paralelo em todo PR (labels automáticas + validação do título em Conventional Commits);.github/workflows/release-please.ymlroda em todo push emmastere mantém um PR de release acumulado (changelog + versão) — mesclá-lo é o que cria a tag.
Docker
cp .env.example .env
# Edite o .env com suas chaves
docker compose up -d
# Chat web: http://localhost:8080
docker-compose.yml sobe PostgreSQL (pgvector/pgvector:pg16), Redis (redis-stack-server, com RediSearch/RedisJSON para o cache LLM distribuído) e Qdrant — o backend do Vectora em si não roda como container, roda no host e se conecta a esses três serviços quando STORAGE_MODE=complete.
VPS com HTTPS (Traefik):
cp .env.example .env
# Defina VECTORA_DOMAIN e ACME_EMAIL
docker network create traefik-public
docker compose -f docker-compose.yml -f docker-compose.traefik.yml up -d
# Chat web: https://vectora.seudominio.com
Referência de CLI
vectora [comando] [opções]
Comandos:
(sem args) Imprime este help
start Backend completo + SPA (fullstack)
start --headless Sobe somente o backend, sem janela Electron
web Sobe o webapp HTTP com Electron/Chromium, sem bandeja Python
config Mostra/edita settings; subcomandos: keys, docker, qdrant, redis
storage Migrations, diagnóstico, backup/restore, wizard BaaS
sessions Listar todas as sessões salvas
Opções de start:
--headless Não inicia Electron nem bandeja (modo servidor)
--host <host> Host de escuta (padrão: 0.0.0.0)
--port <n> Porta (padrão: 8080)
--ssl-certfile/-keyfile <pem> TLS (serve em https://)
Diagnóstico da instalação:
vectora --tests Baixa pytest sob demanda e executa smoke tests contra o backend instalado.
Requer rede na primeira execução; não altera o build público com deps de teste.
Dados e Persistência
Todos os dados ficam em ~/.vectora/:
~/.vectora/
├── config.toml # Configuração de runtime (provedores, storage)
├── auth.key # Chave JWT (gerada automaticamente, perm 600)
├── data/
│ ├── vectora.db # Usuários, sessões, memórias, checkpoints (SQLite WAL)
│ ├── embedding_queue.db # Fila de embeddings assíncrona (SQLite)
│ ├── traces.db # Spans de observabilidade (SQLite)
│ └── lancedb/ # Banco vetorial (LanceDB, modo lite)
├── artifacts/ # Planos, specs, guias (output do create_artifact)
│ └── {session_id}/*.md
├── secrets/
│ ├── system.kdbx # Vault de segredos do sistema (formato KeePassXC)
│ └── users/{id}.kdbx # Vault por usuário (chaves de API, SSH)
├── skills/{user_id}/ # Skills instaladas (formato SKILL.md)
├── safe_roots.json # Caminhos confiáveis configurados pelo admin
├── workspaces.json # Workspaces registrados
└── license_cache.json # Cache de validação de licença (TTL 6h / 48h offline)
No modo complete (STORAGE_MODE=complete), checkpointer e sessões vão para PostgreSQL, vetores para Qdrant, e cache/KV para Redis — usuários, auth e settings continuam sempre em SQLite, independente do modo.
Referência de Ferramentas
Mais de 70 tools registradas, organizadas por categoria:
| Categoria | Ferramentas |
|---|---|
| Arquivos | file_read, file_edit, file_write, grep, list_dir, terminal, create_artifact |
| Git | 14 operações — status, log, diff, branch, checkout, commit, push, pull, stage/unstage, stash, merge, compare |
| GitHub | gh_issue_create/list/view/comment, gh_pr_create/list/view/merge (via gh CLI) |
| Web | web_search, web_fetch + extração/crawl |
| RAG | vector_search, embedding, ingest_docs, manage_retriever |
| Context Graph | build_knowledge_graph, graph_query, graph_explain, graph_path, graph_update, graph_affected |
| Memória | save_memory, get_memory, delete_memory |
| Workspace | workspace_list, workspace_describe, bucket_summary |
| Integrações | Jira, Slack, Linear, Google Drive, Gmail, Notion (opcionais, via OAuth/API key por workspace) |
| Utilitárias | time_*, hash_*, base64_*, regex_test, json_query, jwt_decode, http_request |
| MCP | call_mcp_tool — delega para MCP servers de terceiros configurados pelo usuário |
Testes
O projeto segue TDD (par caminho-feliz + caminho-de-erro no mesmo teste). Contagem atual (verificada via execução real das suítes):
| Suíte | Arquivos | Testes | Como rodar |
|---|---|---|---|
Backend — unit (tests/unit/) |
137 | 2.387 | uv run pytest tests/unit -q |
| Backend — integration | 5 | 43 | uv run pytest tests/integration -q (Postgres/Redis/Qdrant) |
| Backend — e2e | 1 | 6 | uv run pytest tests/e2e -q (execuções reais do agente) |
| Backend — stress | 4 | 7 | uv run pytest tests/stress -q (concorrência, sem APIs externas) |
| Backend — total | 148 | 2.463 | uv run pytest tests -q |
| Frontend — vitest | 90 | 1.008 | pnpm --dir frontend exec vitest run |
| Frontend — Playwright e2e | 2 | 4 | pnpm --dir frontend exec playwright test |
| Total do produto | 240 | ~3.475 | scons tests (raiz do repositório) |
scons coverage roda a mesma suíte com relatório de cobertura (htmlcov/index.html para o backend, frontend/coverage/index.html para o frontend).
Stack de Tecnologia
Backend
| Camada | Tecnologia |
|---|---|
| Linguagem | Python 3.13 / uv |
| Servidor | FastAPI ≥0.138 + Uvicorn — serve API, SSE, WebSocket e a SPA (StaticFiles) |
| Framework de agente | Motor nativo (backend/engine/) — loop de conversa imperativo, sem grafo compilado |
| Providers de LLM | Clients HTTP nativos (backend/llm/<provider>/) para Google, OpenAI, Anthropic, Cohere, Ollama/OpenRouter |
| Banco vetorial | LanceDB (lite, default) / Qdrant (complete) |
| Embeddings + rerank | Cohere embed-multilingual-v3.0 + rerank-multilingual-v3.0, com VoyageAI como alternativa |
| Busca web | Tavily via client HTTP nativo |
| Retrieval esparso | rank-bm25 (híbrido com busca vetorial densa) |
| Context Graph | tree-sitter (Python/JS/TS/Go/Rust/Java/C/C++/JSON) + networkx + rapidfuzz |
| Persistência | SQLite + aiosqlite (WAL) + SessionStore nativo (Postgres via asyncpg no modo complete) |
| Cache/KV | Redis (redis[hiredis], client nativo) — modo complete |
| Terminal | PTY via pywinpty (Windows) / ptyprocess (Unix) |
| Cliente MCP | MCP via SDK oficial mcp (ClientSession) — consome servidores MCP de terceiros |
| Segurança | argon2-cffi (senhas), pyjwt, pynacl, pykeepass (vault KeePassXC), slowapi (rate limit) |
| Interface CLI | Rich |
| Build/Distribuição | Nuitka (compila o backend em C) + PyInstaller (empacota) + Electron + electron-builder |
Vectora MCP questions
How do I add Vectora MCP to Claude Code?
Run claude mcp add --env 'COHERE_API_KEY=<YOUR_COHERE_API_KEY>' --env 'TAVILY_API_KEY=<YOUR_TAVILY_API_KEY>' --env 'ANTHROPIC_API_KEY=<YOUR_ANTHROPIC_API_KEY>' --env 'GOOGLE_API_KEY=<YOUR_GOOGLE_API_KEY>' --env 'LANGSMITH_API_KEY=<YOUR_LANGSMITH_API_KEY>' --env 'OPENAI_API_KEY=<YOUR_OPENAI_API_KEY>' vectora -- uvx vectora-agent in your terminal. Add --scope user to make it available in every project.
How do I add Vectora MCP to Cursor?
Open ~/.cursor/mcp.json and add the server under mcpServers, using the Cursor config shown in the install section above.
Does Vectora support local LLMs?
Yes, Vectora supports multiple providers including Google Gemini, OpenAI, Anthropic, Cohere, or Ollama for a fully local setup.
What kind of tools are included in the workbench?
It includes over 70 native tools such as filesystem access, git operations, a real PTY terminal, web search, RAG, and integrations with Jira, Slack, and Notion.
Can I run Vectora without complex infrastructure?
Yes, the lite mode uses SQLite and LanceDB, requiring no Docker or Postgres for local use or small teams.