Ir para o conteúdo

🤖 Explicar com IA

Configurando injeção de contexto inteligente para sua base de código

Visão geral

Injeção de contexto inteligente é o que separa o 4Geeks AI Studio das ferramentas genéricas de codificação de IA. Ao contrário das ferramentas padrão que analisam trechos de código isoladamente, o AI Factory mapeia toda a sua base de código e injeta o contexto de todo o projeto em cada solicitação – garantindo que a IA entenda sua arquitetura específica, convenções de nomenclatura e lógica de negócios.

Neste tutorial, você aprenderá:

  • Como funciona a injeção de contexto inteligente
  • Como preparar sua base de código para mapeamento de contexto ideal
  • Como configurar regras e convenções de contexto
  • Como verificar a qualidade do contexto no código gerado

Como funciona a injeção de contexto inteligente

Your Repository
    │
    ▼
Codebase Mapping
    ├── File structure analysis
    ├── Dependency graph construction
    ├── Architecture pattern detection
    ├── Naming convention extraction
    └── Business logic identification
    │
    ▼
Context Index Creation
    ├── Module relationships
    ├── API contracts
    ├── Data models
    ├── Configuration patterns
    └── Coding standards
    │
    ▼
Context Injection (per task)
    ├── Relevant modules identified
    ├── Related code snippets included
    ├── Architecture constraints applied
    └── Naming conventions enforced
    │
    ▼
AI Code Generation (with full context)

Etapa 1: Conecte seu repositório

  1. Vá para as configurações do projeto do AI Studio
  2. Navegue até Conexão do Repositório
  3. Conecte seu repositório:
  4. GitHub: autorize 4Geeks a acessar seu repositório
  5. GitLab: forneça o URL e o token da instância do GitLab
  6. Bitbucket: Conecte-se via OAuth ou senha do aplicativo
  7. Selecione as ramificações a serem incluídas (normalmente principais + ramificações de recursos ativos)

Etapa 2: configurar regras de contexto

Documentação de Arquitetura

Forneça ou crie um documento de arquitetura que descreva:

# Project Architecture

## Tech Stack
- Frontend: React 18, TypeScript, Tailwind CSS
- Backend: Node.js, Express, PostgreSQL
- Infrastructure: AWS (ECS, RDS, S3)

## Directory Structure
/src
  /components    # Reusable UI components
  /pages         # Route-level components
  /services      # API clients and business logic
  /hooks         # Custom React hooks
  /utils         # Utility functions
  /types         # TypeScript type definitions

## Key Patterns
- Feature-based module organization
- Repository pattern for data access
- Service layer for business logic
- Custom hooks for shared state logic

Padrões de codificação

Defina suas convenções de codificação:

# Coding Standards

## Naming Conventions
- Components: PascalCase (UserCard.tsx)
- Functions: camelCase (getUserById)
- Constants: UPPER_SNAKE_CASE (MAX_RETRIES)
- Types/interfaces: PascalCase with I prefix (IUser)

## Code Style
- 2-space indentation
- Single quotes for strings
- Semicolons required
- Max line length: 100 characters

## Testing
- Unit tests: Jest, colocated with source files
- Integration tests: Separate /tests directory
- E2E tests: Playwright in /e2e directory

Contratos de API

Se você tiver especificações OpenAPI/Swagger, esquemas GraphQL ou definições de protobuf, forneça-os:

/api
  openapi.yaml      # REST API specification
  graphql/
    schema.graphql  # GraphQL schema

Etapa 3: Definir níveis de prioridade de contexto

Nem todo código é igualmente importante para o contexto. Configure níveis de prioridade:

Prioridade O que está incluído Quando usado
Crítico Arquitetura central, utilitários compartilhados, definições de tipo Cada tarefa
Alto Módulos relacionados, contratos de API, esquemas de banco de dados A maioria das tarefas
Médio Componentes similares, serviços relacionados Tarefas específicas de recursos
Baixo Código histórico, módulos obsoletos Raramente incluído

Configuração

  1. Vá para Configurações de fábrica de IA → Configuração de contexto
  2. Estabeleça regras de prioridade:
  3. Sempre inclua: tipos de núcleo, utilitários compartilhados, arquivos de configuração
  4. Incluir quando relevante: Módulos relacionados, endpoints de API
  5. Excluir: node_modules, dist, artefatos de construção, acessórios de teste
  6. Defina padrões de arquivo:
    Always include:
    - src/types/**/*.ts
    - src/utils/**/*.ts
    - src/config/**/*
    
    Include when relevant:
    - src/components/**/*.tsx
    - src/services/**/*.ts
    
    Exclude:
    - **/*.test.ts
    - **/*.spec.ts
    - node_modules/**
    - dist/**
    

Etapa 4: verifique a qualidade do contexto

Depois que seu arquiteto sênior concluir o mapeamento inicial:

Verifique o Relatório de Contexto

  1. Vá para AI Factory → Relatório de Contexto
  2. Revisão:
  3. Arquivos mapeados: total de arquivos indexados por contexto
  4. Gráfico de dependências: representação visual dos relacionamentos dos módulos
  5. Padrões de arquitetura: Padrões detectados (MVC, Repositório, etc.)
  6. Convenções de nomenclatura: convenções extraídas
  7. Cobertura: % da base de código mapeada com sucesso

Teste de injeção de contexto

Envie uma tarefa de teste e verifique:

  1. Consciência de arquitetura: O código gerado segue seus padrões?
  2. Consistência de nomenclatura: as convenções são aplicadas corretamente?
  3. Precisão da importação: as importações são dos módulos corretos?
  4. Uso de tipo: os tipos existentes são reutilizados em vez de redefinidos?

Melhores práticas

Prepare sua base de código

  • Limpe antes de conectar: remova código morto, corrija problemas óbvios
  • Documente as principais decisões: Adicione ADRs (Registros de Decisão de Arquitetura)
  • Manter definições de tipo: os tipos TypeScript são cruciais para o contexto
  • Mantenha os testes separados: exclua os arquivos de teste do contexto para reduzir o ruído

Otimize o tamanho do contexto

  • Seja seletivo: inclua apenas o necessário para a geração do código
  • Use abstrações: documentos de arquitetura de alto nível são mais valiosos que qualquer arquivo
  • Atualizar regularmente: execute novamente o mapeamento de contexto após refatorações importantes
  • Monitorar o uso de tokens: contexto maior = mais tokens = custo mais alto

Problemas e soluções comuns

Edição Solução
IA gera código que não corresponde aos padrões Adicionar documentação padrão explícita ao contexto
Importações incorretas Verifique a precisão do gráfico de dependência
Tipos redefinidos em vez de reutilizados Certifique-se de que os arquivos de tipo estejam em “Sempre incluir”
Muitos tokens consumidos Reduza o escopo do contexto, exclua arquivos desnecessários
Contexto de lógica de negócios ausente Adicione documentação específica do domínio

O que vem a seguir?

Precisa de ajuda?


Ainda tem dúvidas? Pergunte na Discord or explore tutoriais