feat: finish upload project

Author: jhowbhz

.github/workflows/ci.yml

@@ -0,0 +1,38 @@
+name: CI
+
+on:
+  push:
+    branches: [ main, master ]
+  pull_request:
+    branches: [ main, master ]
+
+jobs:
+  validate:
+    runs-on: ubuntu-latest
+
+    steps:
+    - uses: actions/checkout@v3
+
+    - name: Set up Python
+      uses: actions/setup-python@v4
+      with:
+        python-version: '3.x'
+
+    - name: Validate JSON files
+      run: |
+        # Encontra todos os .json e tenta parsear com python -m json.tool
+        # Se falhar, o script para e o CI falha.
+        find . -name "*.json" -not -path "./.git/*" -print0 | xargs -0 -I {} bash -c 'echo "Checking {}"; python3 -m json.tool "{}" > /dev/null'
+
+    - name: Check if README index is up to date
+      run: |
+        python3 scripts/update_readme_tree.py
+        # Se houver mudanças (git status não vazio), significa que o autor esqueceu de rodar o script.
+        if [[ -n $(git status --porcelain README.md) ]]; then
+          echo "❌ README.md is out of sync with directory structure."
+          echo "Please run 'python scripts/update_readme_tree.py' and commit the changes."
+          git diff README.md
+          exit 1
+        else
+          echo "✅ README.md is up to date."
+        fi

CONTRIBUTING.md

@@ -0,0 +1,68 @@
+# Guia de Contribuição
+
+Obrigado por considerar contribuir com o **APIBrasil MCP Client**! 🎉
+
+Este repositório é uma base de conhecimento comunitária para centralizar configurações e exemplos de integração da APIBrasil com o ecossistema de IA.
+
+## Como Contribuir
+
+### 1. Adicionando uma Nova Integração
+
+Se você testou a APIBrasil em uma nova ferramenta (IDE, Chatbot, Low-Code), siga estes passos:
+
+1.  **Escolha a Categoria**:
+    *   `clientes-ai/` (Frontends de Chat como Claude, LibreChat)
+    *   `ide-editores/` (VS Code, JetBrains, Cursor)
+    *   `chatbots-ai/` (Builders como Typebot, Flowise)
+    *   `lowcode-automacao/` (n8n, Make, Zapier)
+    *   `programacao/` (Exemplos de código puro)
+
+2.  **Crie a Pasta**:
+    Use o nome da ferramenta em *snake_case* (ex: `minha_ferramenta`).
+    ```bash
+    mkdir ide-editores/minha_ferramenta
+    ```
+
+3.  **Adicione a Documentação**:
+    Crie um arquivo `README.md` dentro da pasta. Use este template básico:
+    ```markdown
+    # Integração com [Nome da Ferramenta]
+
+    Breve descrição da ferramenta.
+
+    ## Configuração
+    Passo a passo...
+
+    ## Exemplo
+    Código ou screenshot...
+    ```
+
+4.  **Adicione Arquivos de Configuração (Opcional)**:
+    Se a ferramenta usa arquivos JSON/YAML de configuração, inclua um exemplo na mesma pasta (ex: `settings.json`).
+
+### 2. Atualizando o Índice
+
+Sempre que adicionar ou remover pastas, você **deve** rodar o script de atualização para manter o `README.md` principal sincronizado:
+
+```bash
+python scripts/update_readme_tree.py
+```
+
+Se você não rodar este script, o CI (Integração Contínua) falhará e seu Pull Request não será aceito.
+
+### 3. Padrão de JSON
+
+Se estiver adicionando arquivos `.json`:
+*   Certifique-se de que é um JSON válido.
+*   Não deixe vírgulas sobrando no final de listas/objetos.
+*   Use indentação de 2 ou 4 espaços.
+
+## Reportando Bugs
+
+Use a aba [Issues](https://github.com/apibrasil/apibrasil-mcp-client/issues) para reportar:
+*   Configurações que pararam de funcionar.
+*   Erros na documentação.
+*   Sugestões de novas ferramentas.
+
+---
+**Dica:** Mantenha os exemplos simples e focados na conexão. Não inclua tokens reais nos seus commits!

README.md

@@ -0,0 +1,19 @@
+# Integração com Typebot
+
+O Typebot executa fluxos rápidos e stateless. O protocolo MCP (que é stateful via SSE) não é ideal para conexão direta via blocos nativos HTTP do Typebot.
+
+## Como Integrar
+
+### Opção 1: Via API REST Direta (Recomendado)
+Como este servidor MCP é um wrapper da APIBrasil, a forma mais robusta no Typebot é chamar a API direta:
+- Use o bloco **HTTP Request**.
+- URL: `https://gateway.apibrasil.io/api/v2/...`
+- Auth: Bearer Token.
+
+### Opção 2: Via Cloud Function / Wrapper
+Se precisar *obrigatoriamente* passar pelo servidor MCP (ex: para aproveitar a lógica de ferramentas unificada):
+
+1. Crie uma **Cloud Function** (AWS Lambda / Vercel Edge) que faz o handshake MCP.
+2. Chame essa função no Typebot via bloco HTTP.
+
+Não é possível conectar SSE nativamente dentro do fluxo de chat padrão do Typebot.

assets/banner.svg

@@ -0,0 +1,34 @@
+# Integração com Botpress
+
+## Execute Code Card
+
+No Botpress Studio, adicione um card **Execute Code** no seu fluxo.
+
+```javascript
+// Input variables
+const cep = workflow.cep; // Supondo que você capturou isso antes
+const token = env.APIBRASIL_TOKEN;
+const device = env.APIBRASIL_DEVICE;
+
+try {
+  const response = await axios.post(
+    'https://gateway.apibrasil.io/api/v2/cep/cep',
+    { cep: cep },
+    {
+      headers: {
+        'Authorization': `Bearer ${token}`,
+        'DeviceToken': device
+      }
+    }
+  );
+
+  // Output
+  workflow.endereco = response.data;
+  workflow.found = true;
+} catch (error) {
+  workflow.found = false;
+  console.log(error);
+}
+```
+
+Certifique-se de configurar as variáveis de ambiente no Botpress Cloud.

chatbots-ai/README.md

@@ -0,0 +1,24 @@
+# Integração com Dify.ai
+
+O Dify aceita **API Extensions** ou **Tools** customizadas via OpenAPI/Swagger.
+
+## Como configurar
+
+Como o MCP usa JSON-RPC sobre SSE, ele não é uma API REST padrão Swagger.
+
+1. **Recomendado:** Use a funcionalidade "Code-based Tool" do Dify (se você rodar o Dify self-hosted).
+2. **Alternativa:** Crie um proxy simples (middleware) que converte REST (padrão Dify) para MCP.
+
+### Middleware Exemplo (Python/Flask)
+Crie um app pequeno que recebe POST do Dify `/api/run-tool` e internamente usa o cliente MCP Python para chamar `https://mcp.apibrasil.cloud/mcp`.
+
+```python
+# Seu Middleware
+@app.route('/dify-hook', methods=['POST'])
+async def run_tool():
+    data = request.json
+    # Conecta no MCP e executa
+    # Retorna o resultado JSON pro Dify
+```
+
+Em breve, plataformas como Dify devem suportar o protocolo MCP nativamente nas configurações de "Model Providers" ou "Tools".

chatbots-ai/botpress/README.md

@@ -0,0 +1,25 @@
+# Integração com Flowise
+
+O Flowise é uma ferramenta Low-Code para construir LLM Apps e suporta integração via **Custom Tools**.
+
+## Passo a Passo
+
+1. No canvas do Flowise, procure por **Tools**.
+2. Escolha **Custom Tool**.
+3. Defina o Schema da ferramenta (copie do código fonte da tool desejada, ex: `cep_lookup`).
+4. No campo "Javascript Function", implemente a chamada ao servidor MCP:
+
+```javascript
+/* 
+  Para Flowise, o ideal é usar o SDK do MCP se o ambiente permitir,
+  ou fazer a chamada HTTP POST direta se você já tiver um sessionId fixo (avançado).
+*/
+const fetch = require('node-fetch');
+
+// ... lógica de chamada ...
+```
+
+**Novidade:** O Flowise está implementando suporte nativo ao protocolo MCP. Assim que lançado, você poderá apenas:
+1. Arrastar um nó "MCP Client".
+2. Colocar a URL: `https://mcp.apibrasil.cloud/mcp`.
+3. Conectar ao seu Agente.

chatbots-ai/dify/README.md

@@ -0,0 +1,35 @@
+# Integração com LangFlow
+
+O LangFlow permite criar componentes customizados em Python.
+
+## Criando um Componente MCP
+
+1. Arraste um **Custom Component**.
+2. Edite o código Python.
+3. Use o código abaixo para conectar ao servidor MCP:
+
+```python
+from langflow import CustomComponent
+from mcp.client.sse import sse_client
+import asyncio
+
+class MCPToolComponent(CustomComponent):
+    display_name = "APIBrasil MCP"
+    description = "Executa ferramentas via MCP"
+
+    def build_config(self):
+        return {
+            "tool_name": {"display_name": "Nome da Tool", "value": "cep_lookup"},
+            "arguments": {"display_name": "Argumentos (JSON)", "value": "{}"},
+        }
+
+    def build(self, tool_name: str, arguments: dict):
+        async def run_mcp():
+            url = "https://mcp.apibrasil.cloud/mcp"
+            async with sse_client(url) as client:
+                result = await client.call_tool(tool_name, arguments)
+                return str(result)
+        
+        # Nota: LangFlow roda em loop assíncrono, pode precisar de ajustes
+        return asyncio.run(run_mcp())
+```