Back to Browse

Vectora MCP Server

AI & MLUse Caution3.2MCP RegistryLocal
Free

Server data from the Official MCP Registry

AI assistant with RAG, web search, filesystem and memory. MCP sub-agent for Claude Code.

About

AI assistant with RAG, web search, filesystem and memory. MCP sub-agent for Claude Code.

Security Report

3.2
Use Caution3.2High Risk

Vectora is an AI assistant MCP server with reasonable security practices but several concerns. The codebase properly manages API keys through environment variables and avoids hardcoding credentials. However, there are notable issues: broad subprocess execution capabilities without input sanitization in terminal tools, potential path traversal risks in file operations, missing rate limiting on API calls, and overly permissive error handling that could leak sensitive information. The permissions are appropriate for the stated RAG/coding use case, but the implementation has gaps in input validation and security controls. Supply chain analysis found 16 known vulnerabilities in dependencies (1 critical, 10 high severity). Package verification found 1 issue.

3 files analyzed · 26 issues found

Security scores are indicators to help you make informed decisions, not guarantees. Always review permissions before connecting any MCP server.

Permissions Required

This plugin requests these system permissions. Most are normal for its category.

env_vars

Check that this permission is expected for this type of plugin.

File System Read

Reads files on your machine. Normal for tools that analyze or process local data.

File System Write

Writes or modifies files on your machine. Check that this is expected for the tool.

file_system

Check that this permission is expected for this type of plugin.

HTTP Network Access

Connects to external APIs or services over the internet.

Shell Command Execution

Runs commands on your machine. Be cautious — only use if you trust this plugin.

database

Check that this permission is expected for this type of plugin.

process_spawn

Check that this permission is expected for this type of plugin.

What You'll Need

Set these up before or after installing:

Google Gemini API key (recommended free-tier LLM provider)Required

Environment variable: GOOGLE_API_KEY

Cohere API key — required for RAG embeddings and rerankingRequired

Environment variable: COHERE_API_KEY

Tavily API key — required for web search and URL extractionRequired

Environment variable: TAVILY_API_KEY

OpenAI API key (optional — alternative LLM provider)Required

Environment variable: OPENAI_API_KEY

Anthropic API key (optional — alternative LLM provider)Required

Environment variable: ANTHROPIC_API_KEY

LangSmith API key (optional — tracing and observability)Required

Environment variable: LANGSMITH_API_KEY

How to Install

Add this to your MCP configuration file:

{
  "mcpServers": {
    "vectora-agent": {
      "command": "uvx",
      "args": [
        "vectora-agent==0.1.0rc3"
      ],
      "env": {
        "COHERE_API_KEY": "your-cohere-api-key-here",
        "GOOGLE_API_KEY": "your-google-api-key-here",
        "OPENAI_API_KEY": "your-openai-api-key-here",
        "TAVILY_API_KEY": "your-tavily-api-key-here",
        "ANTHROPIC_API_KEY": "your-anthropic-api-key-here",
        "LANGSMITH_API_KEY": "your-langsmith-api-key-here"
      }
    }
  }
}

Some servers take additional arguments. See the repository for details.

Documentation

View on GitHub

From the project's GitHub README.

Vectora

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 + embeddings + reranking opcional) 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) é um while imperativo, 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.
  • Seleção explícita de providers — LLM e cada capacidade de IA podem ser configurados separadamente; uma falha não troca silenciosamente de provider nem de modelo.
  • 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.
  • Múltiplos providers de IA — provedores diretos, serviços locais e roteadores são selecionados conforme a capacidade; veja a matriz abaixo.

Providers e tipos de IA

O Vectora configura cada capacidade de IA de forma independente. Os nomes nesta tabela são famílias de serviço ou integração, não uma lista de modelos. Um provider aparecer aqui não significa que toda rota, conta ou modelo dele ofereça todas as capacidades: o endpoint e o modelo configurados precisam implementar o protocolo correspondente.

Tipo de IAPara que serve no VectoraProviders e integrações disponíveis
Geração de linguagem (LLM)Conversa, síntese, geração de código e uso de ferramentas pelo agente.Google Gemini, OpenAI, Anthropic, Cohere, Ollama, OpenRouter, 9Router, llama.cpp e Docker Model Runner.
Decision ModelsDecisões estruturadas do harness, como escolher entre opções, avaliar critérios e produzir scores; é uma configuração separada do LLM de conversa.Clef local, Laya local, Clef API e JEV API; o catálogo também identifica Google Gemini Decision 1 quando a API Google está configurada (o endpoint especializado ainda não é um adapter de execução do harness).
EmbeddingsConverter documentos e consultas em vetores para busca semântica e RAG.OpenAI, Google Gemini, Cohere e Voyage por APIs próprias; Ollama local; OpenRouter; 9Router; Docker Model Runner; llama.cpp local com endpoint compatível. O catálogo do OpenRouter possui descoberta específica de modelos de embedding.
RerankingReordenar candidatos recuperados por relevância para a consulta antes de passá-los ao agente.Cohere, Voyage, OpenRouter e llama.cpp local com endpoint habilitado; modelos expostos por roteadores compatíveis são classificados conforme metadados e endpoint de rerank.
Entrada visual (visão)Interpretar imagens anexadas ou imagens usadas por ferramentas multimodais.OpenAI, Google Gemini e Anthropic; Ollama e OpenRouter dependem do modelo e da rota configurados.
Geração de imagemCriar imagens por meio das ferramentas de mídia.Google Gemini e OpenAI; Ollama e OpenRouter quando configurados com modelo e rota compatíveis.
Áudio: transcrição (STT)Converter fala gravada em texto.Google Gemini, OpenAI e OpenRouter; outros serviços só quando o adapter e a rota de transcrição estiverem disponíveis.
Áudio: síntese (TTS)Gerar fala a partir de texto.Google Gemini e OpenAI; Ollama e OpenRouter quando configurados com modelo e rota compatíveis; helper local de fala nas plataformas suportadas.
VídeoAnalisar ou gerar conteúdo de vídeo pelas ferramentas de mídia.Análise via Google Gemini; geração via Ollama ou OpenRouter quando a rota estiver configurada e aceitar essa capacidade.

Embeddings e reranking são selecionados pelo modelo na tela IA Models. O catálogo busca modelos nos providers configurados e classifica capacidades por metadados oficiais, endpoints específicos e uma lista curada; na tela Provider Routing, a detecção pode ser atualizada e modelos sem evidência suficiente ficam marcados como não identificados. Roteadores só executam uma capacidade quando oferecem o endpoint correspondente e encaminham para um modelo compatível. Trocar o modelo de embedding exige reindexar a coleção para não misturar vetores incompatíveis. Credenciais e endpoints são configurados em Integrações e Provider Routing, nunca junto à seleção do modelo.


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:

AgentePapelFerramentas principais
orchestratorSupervisor — responde direto OU delega para coder/searchcreate_artifact, save_memory, get_memory, delete_memory, RAG
coderFilesystem, terminal, git — geração e revisão de códigofile_read, file_edit, file_write, grep, list_dir, terminal, tools de git
searchBusca 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)

ScoreCaminho
≥ 0.7Injeção direta no contexto — alta confiança
0.4–0.7Rerank (provider configurado) → injeção
< 0.4Cai 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:

AbaO 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.
GitStatus (staged/unstaged/untracked), diff por arquivo com hunks, histórico de commits, stash e worktrees.
SearchBusca em todo o workspace (arquivos + conteúdo).
PlanPlanos, specs e guias gerados pelo agente (create_artifact, markdown em ~/.vectora/artifacts/).
Segundo planoTarefas em segundo plano da sessão + histórico de execuções.
PreviewConfigura 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 e tipos de arquivo a ingerir, e gestão de coleções (listar/apagar).
Context GraphConstró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.
TerminalShell 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

RequisitoNotas
Python 3.13Gerenciado pelo uv — fixado em 3.13 (requires-python do projeto)
Node.js 26Para o frontend web; versão e pnpm 11.5 são fixados pelo workspace
Chave TavilyBusca web — plano gratuito
Provider de IAConfigure as capacidades desejadas em Integrações e Modelos; Cohere não é obrigatório para RAG.

Início rápido (a partir do código fonte)

git clone https://github.com/vectora-company/vectora.git
cd vectora

# Linux: prepara toolchains e dependências do sistema (opcional)
# ./dotfiles.sh

# Instalar dependências do projeto em qualquer plataforma
uv run --locked scons install

# Copiar e preencher suas chaves de API
cp .env.example .env
# Edite o .env: GOOGLE_API_KEY, COHERE_API_KEY, TAVILY_API_KEY

# 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

No Windows/macOS, instale uv, Python 3.13, Node.js 26 e pnpm 11.5 e execute uv run --locked scons install antes de iniciar o projeto.

scons install começa informando o sistema, a arquitetura e, no Linux, a distribuição; depois sincroniza todos os grupos Python, executa pnpm ci, garante o binário nativo do Electron, baixa NATS e FFmpeg/FFprobe para resources/ (conforme a arquitetura detectada) e, só no macOS, compila o helper de fala nativo. Ao final lista o que ficou instalado. No Linux, dotfiles.sh é opcional e prepara a toolchain separadamente. pnpm ci recria frontend/node_modules conforme o lockfile. O app usa o Chromium distribuído com Electron; Playwright é apenas cliente CDP e não precisa baixar browsers.

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 empacotamento do backend (build-hybrid.py, chamado pelo scons) usa só o PyInstaller em modo --onedir: ele coleta o launcher, o pacote backend/ (código e arquivos de dados, inclusive backend/defaults.env, onde o release injeta o VECTORA_APP_SECRET) e as libs Python em dist/vectora/, com os sidecars NATS e FFmpeg/FFprobe (e o helper de fala no macOS). O backend não é compilado em C e o build não exige toolchain C (MSVC, clang ou gcc). O app secret fica no instalador como arquivo legível: não é proteção, quem baixa o instalador consegue lê-lo.

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 contra master e em todo push em master, sem gate manual. Só o release-native (matriz Linux/macOS/Windows, backend empacotado com PyInstaller + electron-builder) continua condicionado, agora numa tag v* real ou workflow_dispatch manual. .github/workflows/pr-gate.yml roda a fila de verificações de todo PR (título em Conventional Commits, labels, milestone, pre-commit, contratos e segredos); .github/workflows/release-please.yml roda em todo push em master e 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:

CategoriaFerramentas
Arquivosfile_read, file_edit, file_write, grep, list_dir, terminal, create_artifact
Git14 operações — status, log, diff, branch, checkout, commit, push, pull, stage/unstage, stash, merge, compare
GitHubgh_issue_create/list/view/comment, gh_pr_create/list/view/merge (via gh CLI)
Webweb_search, web_fetch + extração/crawl
RAGvector_search, embedding, ingest_docs, manage_retriever
Context Graphbuild_knowledge_graph, graph_query, graph_explain, graph_path, graph_update, graph_affected
Memóriasave_memory, get_memory, delete_memory
Workspaceworkspace_list, workspace_describe, bucket_summary
IntegraçõesJira, Slack, Linear, Google Drive, Gmail, Notion (opcionais, via OAuth/API key por workspace)
Utilitáriastime_*, hash_*, base64_*, regex_test, json_query, jwt_decode, http_request
MCPcall_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íteArquivosTestesComo rodar
Backend — unit (tests/unit/)1372.387uv run pytest tests/unit -q
Backend — integration543uv run pytest tests/integration -q (Postgres/Redis/Qdrant)
Backend — e2e16uv run pytest tests/e2e -q (execuções reais do agente)
Backend — stress47uv run pytest tests/stress -q (concorrência, sem APIs externas)
Backend — total1482.463uv run pytest tests -q
Frontend — vitest901.008pnpm --dir frontend exec vitest run
Frontend — Playwright e2e24pnpm --dir frontend exec playwright test
Total do produto240~3.475scons 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

CamadaTecnologia
LinguagemPython 3.13 / uv
ServidorFastAPI ≥0.138 + Uvicorn — serve API, SSE, WebSocket e a SPA (StaticFiles)
Framework de agenteMotor nativo (backend/engine/) — loop de conversa imperativo, sem grafo compilado
Providers de LLMClients HTTP nativos (backend/llm/<provider>/) para Google, OpenAI, Anthropic, Cohere, Ollama/OpenRouter
Banco vetorialLanceDB (lite, default) / Qdrant (complete)
Embeddings + rerankAdapters por capacidade para APIs diretas, roteadores compatíveis e runtimes locais; veja Providers e tipos de IA
Busca webTavily via client HTTP nativo
Retrieval esparsorank-bm25 (híbrido com busca vetorial densa)
Context Graphtree-sitter (Python/JS/TS/Go/Rust/Java/C/C++/JSON) + networkx + rapidfuzz
PersistênciaSQLite + aiosqlite (WAL) + SessionStore nativo (Postgres via asyncpg no modo complete)
Cache/KVRedis (redis[hiredis], client nativo) — modo complete
TerminalPTY via pywinpty (Windows) / ptyprocess (Unix)
Cliente MCPMCP via SDK oficial mcp (ClientSession) — consome servidores MCP de terceiros
Segurançaargon2-cffi (senhas), pyjwt, pynacl, pykeepass (vault KeePassXC), slowapi (rate limit)
Interface CLIRich
Build/DistribuiçãoPyInstaller (empacota o backend) + Electron + electron-builder

Frontend

CamadaTecnologia
BundlerVite 8 + TypeScript 6
Framework UIReact 19
RoutingTanStack Router (file-based, type-safe)
Data fetchingTanStack Query
EstadoZustand (20 stores) + useReducer para estado local de UI
EstiloTailwind CSS 4 + Radix UI + shadcn/ui + lucide-react
EditorMonaco Editor (@monaco-editor/react)
Terminal@xterm/xterm + addons (fit, web-links), tema dinâmico via CSS vars
Janelas flutuantesreact-rnd (arquivos abertos como janelas redimensionáveis/arrastáveis)
Markdownreact-markdown + remark-gfm + react-syntax-highlighter
Forms + validaçãoReact Hook Form + Zod
i18nParaglide JS — m() de @/lib/paraglide/messages, sem strings hardcoded
PWAvite-plugin-pwa (manifest + service worker)
TestesVitest + Testing Library (unit/componente) + Playwright (e2e)
Lintoxlint (Oxc, Rust)

Configuração

Chaves de API vão em ~/.vectora/config.toml (criado pelo vectora config keys) ou em um .env local:

# Provedor LLM (detectado automaticamente pelas chaves disponíveis)
LLM_PROVIDER=google-genai
GOOGLE_API_KEY=sua_chave_aqui

# Opcional: credenciais para providers de IA; cada capacidade seleciona o modelo em IA Models
# OPENAI_API_KEY, GOOGLE_API_KEY, COHERE_API_KEY, VOYAGE_API_KEY ou OPENROUTER_API_KEY

# Obrigatório: busca web e extração de URLs
TAVILY_API_KEY=sua_chave_aqui

# Opcional: telemetria nativa
TELEMETRY_ENABLED=true

Licença

O Vectora é software livre sob a GNU Affero General Public License v3.0 (AGPL-3.0-only). O texto completo está em LICENSE.

Em termos práticos, você pode usar, estudar, modificar e redistribuir o código. Se você distribuir uma versão modificada, ou oferecê-la como serviço a outras pessoas pela rede, precisa disponibilizar o código-fonte dessa versão sob a mesma licença.

  • Direitos autorais: © 2026 Vectora Ltda. A Vectora é a titular do código do projeto e pode oferecer o mesmo código sob outra licença, inclusive comercial, a quem não puder cumprir a AGPL. Para isso, ela precisa dos direitos sobre as contribuições recebidas; por isso todo PR de terceiros exige o aceite do CLA.
  • Licença comercial: fale com contato@vectora.company.
  • Dependências de terceiros: a lista e as licenças estão em THIRD_PARTY_NOTICES.md.
  • O nome e a marca "Vectora" não são licenciados pela AGPL; não os use de forma que sugira endosso do seu fork.

Contribuindo e segurança

Reviews

No reviews yet

Be the first to review this server!