DevContext

Fornece aos desenvolvedores uma consciência de contexto contínua e centrada no projeto. Requer um banco de dados TursoDB.

GitHub

Documentação

DevContext: Servidor MCP (Model-Context-Protocol) de Consciência de Contexto Autônoma

Capacite seu fluxo de trabalho de desenvolvimento com consciência de contexto inteligente - O DevContext entende seu código, conversas e padrões de desenvolvimento para fornecer contexto relevante exatamente quando você precisa.

Introdução

O DevContext é um servidor MCP (Model Context Protocol) de ponta, projetado para fornecer aos desenvolvedores consciência de contexto contínua e centrada no projeto. Diferente dos sistemas de contexto tradicionais, o DevContext aprende continuamente e se adapta aos seus padrões de desenvolvimento. O DevContext utiliza métodos sofisticados de recuperação, focando em análise de palavras-chave, grafos de relacionamento e metadados estruturados para fornecer contexto altamente relevante durante o desenvolvimento, compreendendo tanto suas conversas quanto seu código em um nível mais profundo.

O servidor opera com uma instância de banco de dados dedicada a um único projeto, eliminando a complexidade entre projetos e garantindo desempenho com requisitos mínimos de recursos. O DevContext constrói uma compreensão abrangente do seu código - desde a estrutura do repositório até funções individuais - enquanto aprende continuamente e se adapta aos seus padrões de desenvolvimento.

A MELHOR maneira de usar este servidor MCP é seguir o guia abaixo sobre a implementação do sistema de Cursor Rules fornecido, que por sua vez oferece:

Gerenciamento de contexto completamente autônomo
Contexto e uso de documentação externa autônomos
Integração completa do fluxo de trabalho de gerenciamento de tarefas

Tecnologias Principais

Node.js: Ambiente de execução (Node.js 18+)
TursoDB: Banco de dados SQL otimizado para implantação em edge (compatível com SQLite)
Model Context Protocol SDK: Para comunicação padronizada com clientes IDE
Cursor Rules: Gerenciamento autônomo de ambiente de desenvolvimento e fluxo de trabalho
JavaScript/TypeScript: Implementação pura em JavaScript sem dependências externas de ML

Guia de Instalação

Pré-requisitos

Node.js 18.0.0 ou superior
IDE Cursor com suporte a MCP
Conta TursoDB (para o banco de dados)

Passo 1: Configurar o Banco de Dados TursoDB

Cadastre-se no TursoDB:
- Visite Turso e crie uma conta
- O plano gratuito é suficiente para a maioria dos projetos

Instale o Turso CLI (opcional, mas recomendado):

curl -sSfL https://get.turso.tech/install.sh | bash

Autentique-se com o Turso:
```
turso auth login
```
Crie um banco de dados do projeto:
```
turso db create devcontext
```

Obtenha as credenciais do banco de dados:

# Get database URL
turso db show devcontext --url

# Create auth token
turso db tokens create devcontext

Salve tanto a URL quanto o token para o próximo passo.

Passo 2: Configurar o MCP no Cursor (pode ser aplicado a outros IDEs também)

Crie ou edite .cursor/mcp.json no diretório do seu projeto:

{
  "mcpServers": {
    "devcontext": {
      "command": "npx",
      "args": ["-y", "devcontext@latest"],
      "enabled": true,
      "env": {
        "TURSO_DATABASE_URL": "your-turso-database-url",
        "TURSO_AUTH_TOKEN": "your-turso-auth-token"
      }
    }
  }
}

Substitua your-turso-database-url e your-turso-auth-token pelos valores obtidos no Passo 1.

Implementação do Cursor Rules

O DevContext implementa um conjunto sofisticado de Cursor Rules que criam um ambiente de desenvolvimento autônomo. Essas regras orientam os assistentes de IA do Cursor na manutenção do alinhamento do escopo do projeto, na incorporação de documentação atualizada e na implementação de fluxos de trabalho avançados de tarefas.

Fique atento ao DevContext Project Generator, que está chegando em breve e criará uma configuração COMPLETA para o seu projeto, literalmente 10x seu fluxo de trabalho de desenvolvimento.

Componentes Principais das Regras

1. Guia de Uso das Ferramentas MCP do DevContext

A regra principal define uma sequência precisa para a execução das ferramentas:

1. FIRST: Call initialize_conversation_context EXACTLY ONCE at START
2. AS NEEDED: Call update_conversation_context for code changes/new messages
3. AS NEEDED: Call retrieve_relevant_context when specific context is required
4. OCCASIONALLY: Call record_milestone_context for significant achievements
5. LAST: Call finalize_conversation_context EXACTLY ONCE at END

Este fluxo de trabalho garante gerenciamento abrangente de contexto durante toda a sessão de desenvolvimento.

2. Requisitos de Documentação de Bibliotecas Externas

Todo uso de bibliotecas externas deve ser precedido pela recuperação adequada de documentação:

Recuperação de Documentação em Duas Etapas usando Context7
Fallback de Pesquisa na Web para documentação não disponível através do Context7
Síntese de Documentação de Múltiplas Fontes para compreensão abrangente

Isso evita problemas comuns com uso incorreto de APIs, versões incompatíveis ou dependências ausentes.

3. Sistema de Fluxo de Trabalho de Tarefas

O sistema de fluxo de trabalho de tarefas permite:

Gerenciamento estruturado de tarefas em tasks.md
Ordem de implementação baseada em ID de tarefa
Rastreamento de status com metadados de conclusão
Integração de blueprint do projeto para contexto arquitetural

Configurando o Cursor Rules

Crie o Diretório de Regras:
```
mkdir -p .cursor/rules
```
Baixe/Copie e Cole as Regras:

Baixe ou copie e cole o diretório .cursor/rules no seu projeto. Em seguida, copie e cole o conteúdo do arquivo .cursorrules na raiz do seu projeto e cole-o nas configurações de regras do cursor (Cursor Settings -> Rules -> User Rules). Você também deve copiar e colar o arquivo .cursorrules no seu diretório principal.

Personalize o Fluxo de Trabalho de Tarefas (Opcional): Após implementar as cursor rules, reinicie o Cursor e peça para ele criar tarefas para você com base em qualquer ideia de projeto que você possa ter.

Exemplo de Configuração

Abaixo está um exemplo completo de um arquivo mcp.json que configura tanto os servidores MCP DevContext quanto Context7:

{
  "mcpServers": {
    "devcontext": {
      "command": "npx",
      "args": ["-y", "devcontext@latest"],
      "enabled": true,
      "env": {
        "TURSO_DATABASE_URL": "libsql://your-project-db-name.turso.io",
        "TURSO_AUTH_TOKEN": "your_turso_auth_token_here"
      }
    },
    "context7": {
      "command": "npx",
      "args": ["-y", "@upstash/context7-mcp@latest"]
    }
  }
}

Parâmetros Importantes

Parâmetro	Descrição	Valor Padrão
`TURSO_DATABASE_URL`	URL da sua instância TursoDB	Nenhum (Obrigatório)
`TURSO_AUTH_TOKEN`	Token de autenticação para TursoDB	Nenhum (Obrigatório)

Visão Geral do Sistema

O DevContext é um sistema de gerenciamento de contexto de última geração para desenvolvimento de software, implementando o Model Context Protocol (MCP) com técnicas avançadas de recuperação de contexto.

O sistema opera como uma aplicação Node.js com uma base de código JavaScript modular, empacotada em um único arquivo .js usando esbuild. Ele utiliza TursoDB (ou banco de dados SQL similar) como armazenamento persistente para todo o contexto, metadados e logs opcionais de um projeto específico.

Principais Diferenciais:

Recuperação Não-Vetorial: A recuperação de contexto usa análise sofisticada de palavras-chave, grafos de relacionamento e metadados estruturados em vez de embeddings vetoriais
Design Centrado no Projeto: Cada instância do servidor é dedicada a um único projeto, simplificando o gerenciamento de dados
Dependências Mínimas: Restrito aos essenciais - MCP SDK, cliente TursoDB e parsing AST leve
Compreensão Hierárquica: O contexto é compreendido desde a estrutura do repositório até os níveis de função/variável
Priorização Inteligente de Contexto: Pontuação de relevância multifatorial baseada em recência, importância, relacionamentos e foco do desenvolvedor

Componentes Principais

Processamento de Texto

Tokenização ciente de idioma com tratamento especializado para JavaScript/TypeScript, Python, Java, C#, Ruby e Go
Extração de palavras-chave com ponderação específica por idioma
N-gramas respeitando limites semânticos
Detecção de expressões idiomáticas específicas de linguagem

Gerenciamento de Contexto

Indexação de entidades de código e rastreamento de relacionamentos
Segmentação de tópicos de conversa e detecção de propósito
Registro de eventos de linha do tempo e snapshots de marcos
Previsão de áreas de foco com base na atividade do desenvolvedor

Reconhecimento de Padrões

Identificação e armazenamento de padrões de código
Aprendizado automático de padrões a partir de exemplos
Promoção de padrões entre sessões
Detecção de padrões de design

Análise de Intenção e Relevância

Previsão de intenção de consulta
Priorização de contexto multifatorial
Gerenciamento de orçamento de tokens
Integração de contexto entre mudanças de tópico

Ferramentas MCP

O DevContext implementa as seguintes ferramentas MCP que podem ser invocadas pela IDE Cursor:

initialize_conversation_context

Inicializa uma nova sessão de conversa com contexto abrangente do projeto.

Quando usar: No início de cada conversa, exatamente uma vez.

Parâmetros principais:

initialQuery: A primeira mensagem ou pergunta do usuário
contextDepth: Profundidade de contexto mínima, padrão ou abrangente
includeArchitecture: Se deve incluir contexto arquitetural
focusHint: Foco opcional em uma entidade de código específica

Retorna: ID da conversa e resumo inicial do contexto

update_conversation_context

Atualiza o contexto ativo com novas mensagens e mudanças de código.

Quando usar: Após mudanças de código ou novas mensagens serem trocadas.

Parâmetros principais:

conversationId: ID de initialize_conversation_context
newMessages: Novas mensagens trocadas desde a última atualização
codeChanges: Arquivos de código criados ou modificados
preserveContextOnTopicShift: Se deve manter o contexto durante mudanças de tópico

Retorna: Foco atualizado e informações de continuidade de contexto

retrieve_relevant_context

Recupera trechos de contexto relevantes para uma consulta específica.

Quando usar: Quando um contexto específico do projeto é necessário.

Parâmetros principais:

conversationId: ID de initialize_conversation_context
query: Pergunta específica sobre o projeto
constraints: Filtros opcionais para tipos de entidade, caminhos de arquivo, etc.
weightingStrategy: Como priorizar os resultados

Retorna: Trechos de contexto relevantes com explicações

record_milestone_context

Registra marcos significativos de desenvolvimento para referência futura.

Quando usar: Após concluir funcionalidades importantes, corrigir bugs críticos ou tomar decisões arquiteturais.

Parâmetros principais:

conversationId: ID de initialize_conversation_context
name: Nome curto e descritivo do marco
description: Explicação detalhada
milestoneCategory: Categoria (funcionalidade, correção de bug, refatoração, etc.)
assessImpact: Se deve analisar o impacto

Retorna: ID do marco e avaliação de impacto

finalize_conversation_context

Conclui uma conversa, extraindo aprendizados e sugerindo próximos passos.

Quando usar: No final de cada conversa, exatamente uma vez.

Parâmetros principais:

conversationId: ID de initialize_conversation_context
extractLearnings: Se deve identificar e extrair aprendizados
promotePatterns: Se deve promover padrões para o repositório global
generateNextSteps: Se deve sugerir ações de acompanhamento

Retorna: Resumo da conversa, aprendizados extraídos e próximos passos

Arquitetura de Dados

O DevContext usa um banco de dados SQL (TursoDB) com as seguintes tabelas principais:

code_entities: Armazena código indexado de arquivos, funções, classes, etc.
entity_keywords: Mapeia palavras-chave para entidades de código para busca
code_relationships: Rastreia relacionamentos entre entidades de código
conversation_history: Armazena mensagens de conversa
conversation_topics: Segmenta conversas em tópicos coerentes
timeline_events: Registra eventos significativos de desenvolvimento
project_patterns: Armazena padrões de código identificados
focus_areas: Rastreia atenção e intenção do desenvolvedor

O esquema do banco de dados é criado e mantido automaticamente pelo servidor.

Especificações Técnicas

Node.js: Versão 18.0.0 ou superior necessária
Banco de Dados: TursoDB (ou SQLite compatível)
Empacotamento: ESBuild para implantação em arquivo único
Protocolo: Model Context Protocol via @modelcontextprotocol/sdk
Parsing: Parsing AST JavaScript leve (acorn)
Sistemas Operacionais: Multiplataforma (Windows, macOS, Linux)

Considerações de Desempenho

O DevContext é otimizado para desempenho com:

Consultas SQL eficientes com indexação adequada
Cache em memória para dados acessados com frequência
Atualizações incrementais para minimizar o processamento
Operações assíncronas para execução sem bloqueio
Recuperação adaptativa de contexto com base no orçamento de tokens
Tarefas de fundo agendadas durante períodos ociosos

Para grandes bases de código (>100.000 LOC), a indexação inicial pode levar vários minutos, mas as operações subsequentes permanecem rápidas e responsivas.

Segurança

Banco de dados isolado: Cada projeto usa uma instância de banco de dados dedicada
Credenciais seguras: Credenciais do TursoDB gerenciadas por meio de variáveis de ambiente
Validação de entrada: Todas as entradas validadas com esquemas Zod
Consultas parametrizadas: Proteção contra injeção de SQL
Sem APIs externas: Todo o processamento ocorre localmente

Solução de problemas

Problemas comuns e soluções:

Erros de conexão: Verifique as credenciais do TursoDB e a URL do banco de dados
Inicialização lenta no primeiro uso: Normal para grandes bases de código; inicializações subsequentes são mais rápidas
Contexto ausente: Verifique o orçamento de tokens; aumente se necessário
Erros de ferramenta: Garanta que o ID de conversa correto esteja sendo passado entre as ferramentas
Problemas de desempenho: Considere reduzir o escopo dos arquivos indexados ou aumentar o tamanho do cache

Licença

Este projeto é licenciado sob a Licença MIT - consulte o arquivo LICENSE para obter detalhes.

DevContext: Contexto Contínuo para Progresso Contínuo