diff --git a/docs/AI Coding/COMO_CONFIGURAR_VSCODE_COM_IA.md b/docs/AI Coding/COMO_CONFIGURAR_VSCODE_COM_IA.md new file mode 100644 index 0000000..b7a842d --- /dev/null +++ b/docs/AI Coding/COMO_CONFIGURAR_VSCODE_COM_IA.md @@ -0,0 +1,127 @@ +# Guia: Configurando o VSCode com Modelos de IA (OpenRouter, Ollama e Proxy) + +Este guia detalha como configurar o Visual Studio Code para usar diferentes provedores de modelos de linguagem (LLMs) para assistência de codificação, aproveitando a funcionalidade nativa "Bring Your Own Key" (BYOK). + +## 1. Configurando com OpenRouter + +O OpenRouter oferece acesso a uma vasta gama de modelos de diferentes provedores através de uma única API. + +**Passo-a-passo:** + +1. **Obtenha a API Key:** + * Acesse o site do [OpenRouter](https://openrouter.ai/). + * Faça login e navegue até a sua página de "Keys" para criar ou copiar sua chave de API. + +2. **Configure o VSCode:** + * Abra o VSCode e vá para as configurações em JSON (`Ctrl + Shift + P` e procure por `Preferences: Open User Settings (JSON)`). + * Adicione o seguinte bloco de configuração ao seu `settings.json`, substituindo `"MODELS_HERE"` pelos modelos que deseja usar (ex: `"mistralai/mistral-7b-instruct-free"`) e `"YOUR_OPENROUTER_API_KEY"` pela sua chave. + + ```json + "github.copilot.languageModels": [ + { + "provider": "openrouter", + "model": "MODELS_HERE", // Ex: "mistralai/mistral-7b-instruct-free" ou "google/gemini-flash-1.5" + "apiKey": "YOUR_OPENROUTER_API_KEY", + "url": "https://openrouter.ai/api/v1" + } + ] + ``` + + * **Nota:** Você pode adicionar vários modelos e alternar entre eles diretamente no VSCode. + +## 2. Configurando com Ollama (Local e WSL) + +Ollama permite que você execute modelos de linguagem open-source diretamente na sua máquina. + +### a. Ollama Local (Linux/macOS) + +1. **Instale o Ollama:** Siga as instruções de instalação no [site oficial do Ollama](https://ollama.com/). +2. **Baixe um Modelo:** Abra seu terminal e baixe um modelo de codificação. + ```bash + ollama pull codellama + ``` +3. **Configure o VSCode:** Adicione a seguinte configuração ao seu `settings.json`. O Ollama, por padrão, roda em `http://localhost:11434`. + + ```json + "github.copilot.languageModels": [ + { + "provider": "ollama", + "model": "codellama", // Ou qualquer outro modelo que você baixou + "url": "http://localhost:11434" + } + ] + ``` + +### b. Ollama no Windows com WSL (Windows Subsystem for Linux) + +A maneira mais fácil e recomendada é rodar o VSCode diretamente de dentro do ambiente WSL. + +1. **Instale o Ollama no WSL:** Abra seu terminal WSL e instale o Ollama seguindo as instruções para Linux. +2. **Baixe um Modelo no WSL:** + ```bash + ollama pull deepseek-coder + ``` +3. **Abra o VSCode no WSL:** No seu terminal WSL, navegue até a pasta do seu projeto e digite `code .`. Isso abrirá o VSCode conectado ao ambiente WSL. +4. **Configure o VSCode (mesmo que local):** Como o VSCode está rodando "dentro" do WSL, o `localhost` se refere ao próprio WSL. A configuração no `settings.json` é idêntica à de um ambiente Linux nativo. + + ```json + "github.copilot.languageModels": [ + { + "provider": "ollama", + "model": "deepseek-coder", + "url": "http://localhost:11434" + } + ] + ``` + +## 3. Rodando com um Proxy (Ex: OpenAI) + +Se você está atrás de uma VPN ou firewall que bloqueia o acesso direto a serviços como OpenAI, você pode configurar o VSCode para usar um proxy. + +1. **Configure o Proxy no VSCode:** Adicione a seguinte configuração global ao seu `settings.json`, substituindo pelo endereço e porta do seu proxy. + + ```json + "http.proxy": "http://SEU_PROXY_HOST:PORTA" + ``` + +2. **Configure o Provedor de Modelo:** Agora, configure o provedor do modelo (como OpenAI) normalmente. O VSCode automaticamente roteará a requisição através do proxy configurado. + + ```json + "github.copilot.languageModels": [ + { + "provider": "openai", + "model": "gpt-4o", + "apiKey": "YOUR_OPENAI_API_KEY" + } + ] + ``` + * **Importante:** A configuração de `languageModels` não possui um campo de proxy próprio; ela respeita a configuração `http.proxy` global do VSCode. + +## 4. Recomendações de Hardware para Ollama + +O desempenho do Ollama depende principalmente da **RAM** (para carregar o modelo) e da **VRAM** (memória da GPU, para processamento rápido). + +* **RAM Mínima:** + * **8 GB:** Suficiente para modelos de ~3 bilhões (3B) de parâmetros com quantização (ex: `phi-3`). + * **16 GB:** Recomendado para modelos de 7B (ex: `codellama:7b`, `llama3:8b`). Essa é a configuração mais comum e com melhor custo-benefício. + * **32 GB+:** Necessário para modelos de 13B ou maiores (ex: `codellama:34b`). + +* **GPU (Altamente Recomendado):** + * **NVIDIA:** A melhor opção devido ao suporte CUDA. Uma GPU com **8 GB de VRAM** é um bom ponto de partida para modelos de 7B. Para modelos maiores ou processamento mais rápido, 12 GB, 16 GB ou mais são ideais. + * **AMD / Apple Silicon:** O Ollama tem um bom suporte para GPUs AMD (via ROCm) e para o Metal da Apple, tornando MacBooks com chips M1/M2/M3 excelentes máquinas para rodar modelos localmente. + +## 5. Sugestões de Modelos Open-Source (Ollama) + +* **Para Codificação (Coding):** + * `codellama`: Um clássico, treinado especificamente para código. + * `deepseek-coder`: Frequentemente no topo dos benchmarks de codificação. É uma escolha excelente e muito poderosa. + * `starcoder2`: A nova geração do Starcoder, com bom desempenho em várias linguagens. + * `phi-3`: Um modelo menor da Microsoft, surpreendentemente capaz para seu tamanho e ótimo para máquinas com menos recursos. + +* **Para Chat e Dúvidas Gerais (Chat):** + * `llama3`: O Llama 3 da Meta é um dos melhores modelos de chat geral disponíveis hoje. A versão 8B é rápida e muito coerente. + * `mistral`: Rápido e de alta qualidade, uma alternativa excelente ao Llama. + * `qwen2`: Um modelo recente com forte capacidade multilíngue e bom raciocínio. + +* **Qual modelo mais se aproxima do "Claude Code"?** + O "Claude 3 Opus" é um modelo proprietário de ponta, e igualá-lo com open-source é difícil, mas o que mais se aproxima em termos de capacidade de raciocínio complexo sobre código é provavelmente o **`deepseek-coder:33b`**. Ele é amplamente reconhecido pela sua performance de alto nível em tarefas de programação. Para uma experiência mais leve, mas ainda muito forte, o **`deepseek-coder:6.7b`** também é uma aposta fantástica. diff --git a/docs/AI Coding/GUIA_CONTINUE_DEV_vs_COPILOT.md b/docs/AI Coding/GUIA_CONTINUE_DEV_vs_COPILOT.md new file mode 100644 index 0000000..86f9fab --- /dev/null +++ b/docs/AI Coding/GUIA_CONTINUE_DEV_vs_COPILOT.md @@ -0,0 +1,132 @@ +# Guia Alternativo: VSCode com Continue.dev vs. GitHub Copilot + +Este documento serve como um guia para utilizar o `Continue.dev` no VSCode, oferecendo um plano para as mesmas tarefas do guia anterior e um comparativo direto com o GitHub Copilot. + +`Continue.dev` é uma extensão open-source que transforma seu IDE em uma ferramenta de desenvolvimento assistida por LLMs, com foco em flexibilidade, privacidade e customização. + +## 1. Plano de Tarefas com Continue.dev + +A configuração do `Continue.dev` é centralizada em um único arquivo Python (`~/.continue/config.py`), o que permite um controle muito granular. + +**Passo-a-passo geral:** + +1. Instale a extensão `Continue` a partir do VSCode Marketplace. +2. Abra o painel do Continue e clique no ícone de engrenagem ou use o comando `Ctrl/Cmd + L` e digite `> config` para abrir o arquivo `config.py`. +3. Edite o arquivo `config.py` com as configurações desejadas. + +--- + +### a. Configurando com OpenRouter + +Adicione um modelo do OpenRouter à lista de modelos no seu `config.py`. + +```python +from continuedev.core.config import Config +from continuedev.core.models import Models +from continuedev.libs.llm.openrouter import OpenRouter + +# ... outras importações + +config = Config( + models=Models( + default=OpenRouter( + api_key="YOUR_OPENROUTER_API_KEY", + model="mistralai/mistral-7b-instruct-free" # Ou outro modelo de sua escolha + ) + ) +) +``` + +### b. Configurando com Ollama (Local e WSL) + +Execute modelos na sua própria máquina para ter total privacidade e zero custo de API. + +```python +from continuedev.core.config import Config +from continuedev.core.models import Models +from continuedev.libs.llm.ollama import Ollama + +# ... + +config = Config( + models=Models( + default=Ollama(model="codellama") # Garanta que o modelo foi baixado com `ollama pull codellama` + ) +) +``` +**Para WSL:** O princípio é o mesmo. Se o seu servidor Ollama estiver rodando dentro do WSL, o `Continue.dev` (rodando no VSCode conectado ao WSL) irá encontrá-lo em `localhost` sem configurações adicionais. + +### c. Configurando com um Proxy + +`Continue.dev` respeita variáveis de ambiente padrão como `HTTP_PROXY` e `HTTPS_PROXY`. Alternativamente, você pode especificar uma `api_base` para provedores que a suportam. + +**Método 1: Variáveis de Ambiente (Recomendado)** + +No seu terminal, antes de iniciar o VSCode: +```bash +export HTTPS_PROXY="http://SEU_PROXY_HOST:PORTA" +code . +``` + +**Método 2: `api_base` (Para OpenAI e compatíveis)** + +```python +from continuedev.core.config import Config +from continuedev.core.models import Models +from continuedev.libs.llm.openai import OpenAI + +# ... + +config = Config( + models=Models( + default=OpenAI( + api_key="YOUR_OPENAI_API_KEY", + model="gpt-4o", + api_base="https://SUA_URL_DE_PROXY/v1" # Endereço do proxy + ) + ) +) +``` + +## 2. Comparativo: Continue.dev vs. GitHub Copilot + +| Característica | GitHub Copilot | Continue.dev | +| :--- | :--- | :--- | +| **Modelos Suportados** | Modelos proprietários da OpenAI (GPT-3.5, GPT-4) otimizados pela Microsoft. | Quase qualquer modelo: Ollama, OpenAI, Gemini, Claude, OpenRouter, etc. | +| **Custo** | Assinatura paga (mensal/anual). | A extensão é gratuita. O custo é o da API do modelo que você escolher (ou zero, se usar Ollama local). | +| **Código-Fonte** | Fechado. | **Aberto (Open-Source)**. | +| **Privacidade** | O código é enviado aos servidores da Microsoft (com políticas de privacidade). | **Controle total.** Com modelos locais (Ollama), nada sai da sua máquina. | +| **Customização** | Baixa. Algumas opções de configuração e exclusão de arquivos. | **Extremamente alta.** Configuração via Python, criação de comandos (`/slash_commands`), customização de contexto. | +| **Gerenciamento de Contexto** | Automático, baseado nos arquivos abertos. | **Explícito e poderoso.** Use `@` para adicionar arquivos, pastas, documentação, problemas do GitHub e mais ao contexto. | +| **Interface do Usuário** | Foco em autocompletar *inline*. Um painel de chat separado (`Copilot Chat`). | Foco no painel de chat interativo, com autocompletar *inline* como um recurso complementar. | +| **Configuração Inicial**| "Funciona ao ligar" (Out-of-the-box). Praticamente nenhuma configuração. | Requer configuração inicial no arquivo `config.py` para escolher e autenticar seus modelos. | + + +## 3. Plano de Migração: Do Copilot para o Continue.dev + +Migrar é um processo simples e direto: + +1. **Instale o Continue.dev:** Procure por "Continue" no VSCode Marketplace e instale a extensão. +2. **Desabilite o GitHub Copilot:** Para evitar conflitos de atalhos e sugestões duplicadas, é altamente recomendado desabilitar ou desinstalar as extensões `GitHub Copilot` e `GitHub Copilot Chat`. Vá para a aba de Extensões, encontre o Copilot e clique em `Disable (Workspace)`. +3. **Configure seu Primeiro Modelo:** Siga as instruções da **Seção 1** deste guia para configurar seu `config.py` com o provedor de sua escolha (Ollama é um ótimo ponto de partida por ser gratuito e local). +4. **Aprenda o Fluxo de Trabalho:** + * Use `Ctrl + L` para abrir a caixa de diálogo do Continue. + * Use `Ctrl + J` (ou o atalho que configurar) para abrir o painel de chat. + * Digite `/` no chat para ver os comandos disponíveis (ex: `/edit`, `/fix`, `/test`). + * Digite `@` para ver os provedores de contexto (ex: `@file`, `@terminal`, `@docs`). + +## 4. Análise: Ganhos e Perdas na Migração + +### O que você GANHA com a migração para o Continue.dev: + +1. **Flexibilidade Total:** Você não fica preso a um único provedor. Pode usar o melhor modelo para cada tarefa, seja ele open-source, da Google, Anthropic ou OpenAI. +2. **Controle Absoluto e Privacidade:** A capacidade de rodar 100% localmente com Ollama é um ganho imenso para empresas com políticas de privacidade restritas ou para desenvolvedores que não querem que seu código saia da máquina. +3. **Potencial de Custo Zero:** Ao usar modelos locais, o único custo é o do seu próprio hardware. +4. **Customização Profunda:** A capacidade de criar seus próprios comandos e automatizar fluxos de trabalho no `config.py` permite adaptar a ferramenta exatamente às suas necessidades. +5. **Gerenciamento de Contexto Superior:** O sistema de `@` do Continue é mais explícito e poderoso que o gerenciamento automático do Copilot, permitindo que você construa um contexto muito preciso para o LLM. + +### O que você PERDE (ou o que muda): + +1. **A Experiência "Mágica" do Autocomplete:** O autocompletar *inline* do GitHub Copilot é extremamente polido e bem integrado. Embora o Continue.dev também ofereça autocomplete, a experiência do Copilot é frequentemente considerada o padrão ouro em termos de fluidez. +2. **Simplicidade "Out-of-the-Box":** O Copilot exige quase zero configuração. O Continue.dev tem uma curva de aprendizado inicial, exigindo que você configure seu primeiro modelo no `config.py`. +3. **Modelo "Tudo-em-Um" Otimizado:** Com o Copilot, você recebe um modelo de alta qualidade que a Microsoft otimizou para tarefas de codificação. Com o Continue, a qualidade da assistência depende inteiramente do modelo que *você* escolhe e configura. diff --git a/mcphub/.config/mcphub/servers.json b/mcphub/.config/mcphub/servers.json index ce236ad..9d739c6 100644 --- a/mcphub/.config/mcphub/servers.json +++ b/mcphub/.config/mcphub/servers.json @@ -1,5 +1,14 @@ { "mcpServers": { + "time-docker": { + "command": "docker", + "args": [ + "run", + "-i", + "--rm", + "mcp/time" + ] + }, "context7": { "disabled": false, "headers": { @@ -14,6 +23,10 @@ "Authorization": "Bearer ${GITHUB_PERSONAL_ACCESS_TOKEN}" }, "url": "https://api.githubcopilot.com/mcp/" + }, + "playwright": { + "command": "npx", + "args": ["@playwright/mcp@latest"] } } } diff --git a/vscode/.config/Code/User/mcp.json b/vscode/.config/Code/User/mcp.json new file mode 100644 index 0000000..44cdd00 --- /dev/null +++ b/vscode/.config/Code/User/mcp.json @@ -0,0 +1,32 @@ +{ + "servers": { + "time": { + "command": "docker", + "args": [ + "run", + "-i", + "--rm", + "mcp/time" + ] + }, + "context7": { + "disabled": false, + "headers": { + "Accept": "application/json, text/event-stream", + "CONTEXT7_API_KEY": "${CONTEXT7_API_KEY}" + }, + "url": "https://mcp.context7.com/mcp" + }, + "github": { + "disabled": false, + "headers": { + "Authorization": "Bearer ${GITHUB_PERSONAL_ACCESS_TOKEN}" + }, + "url": "https://api.githubcopilot.com/mcp/" + }, + "playwright": { + "command": "npx", + "args": ["@playwright/mcp@latest"] + } + } +} \ No newline at end of file diff --git a/vscode/README.md b/vscode/README.md new file mode 100644 index 0000000..4aafd78 --- /dev/null +++ b/vscode/README.md @@ -0,0 +1,33 @@ +# VSCODE CONFIGS + + +## Using XDG + +No Linux, o Visual Studio Code segue o padrão XDG Base Directory para armazenar as configurações do usuário e dados da aplicação. +Os caminhos padrão são: + +**1. Configurações de Usuário (XDG_CONFIG_HOME)** + +Os arquivos de configuração (como o `settings.json` e `keybindings.json`) ficam no diretório definido pela variável `$XDG_CONFIG_HOME`. Se esta variável não estiver definida, o padrão é `$HOME/.config`. + +- Caminho: `$HOME/.config/Code/User/`. +- Versão OSS: Se você usa o VS Code Open Source (code-oss), o caminho costuma ser `$HOME/.config/Code - OSS/User/` ou `~/.config/vscode-oss/`. + +**2. Cache (XDG_CACHE_HOME)** + +- Arquivos temporários e cache de ferramentas (como o C++) são armazenados no diretório de cache. +- Caminho: $HOME/.cache/Code/ ou $XDG_CACHE_HOME/vscode-cpptools/. + +**3. Dados e Extensões (XDG_DATA_HOME)** + +Embora o VS Code tradicionalmente use `~/.vscode/extensions` para extensões, versões baseadas em servidor ou implementações estritas do padrão XDG podem mover dados para o diretório de dados. +- Caminho: $HOME/.local/share/Code/. + +**Resumo dos principais arquivos no padrão XDG:** + +| Tipo de Arquivo | Localização Padrão (Linux) | +|-----------------|----------------------------| +| Configurações (JSON) | ~/.config/Code/User/settings.json | +| Atalhos de Teclado | ~/.config/Code/User/keybindings.json | +| Snippets de Usuário | ~/.config/Code/User/snippets/ | +| Configurações MCP | ~/.vscode/mcp.json (dentro do workspace) | \ No newline at end of file