Skip to content

Commit 4d62054

Browse files
jhowbhzjhowbhz
authored
upload: examples code
1 parent 8e64417 commit 4d62054

File tree

5 files changed

+331
-0
lines changed

5 files changed

+331
-0
lines changed

‎csharp/README.md‎

Lines changed: 78 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,78 @@
1+
# Consumindo APIBrasil MCP com C# (.NET)
2+
3+
Exemplo usando `HttpClient`.
4+
5+
## 1. Código (Program.cs)
6+
7+
```csharp
8+
using System;
9+
using System.Net.Http;
10+
using System.Text;
11+
using System.Threading.Tasks;
12+
using System.IO;
13+
14+
class Program
15+
{
16+
static async Task Main(string[] args)
17+
{
18+
var client = new HttpClient();
19+
string baseUrl = "https://mcp.apibrasil.cloud/mcp";
20+
21+
Console.WriteLine("Conectando ao SSE...");
22+
23+
// 1. Ler stream SSE para capturar URL de sessão
24+
using (var stream = await client.GetStreamAsync(baseUrl))
25+
using (var reader = new StreamReader(stream))
26+
{
27+
string line;
28+
string postUrl = null;
29+
30+
while ((line = await reader.ReadLineAsync()) != null)
31+
{
32+
Console.WriteLine($"Recebido: {line}");
33+
if (line.StartsWith("data: "))
34+
{
35+
var endpoint = line.Substring(6).Trim();
36+
// Constrói URL completa
37+
postUrl = "https://mcp.apibrasil.cloud" + endpoint;
38+
Console.WriteLine($"Session URL: {postUrl}");
39+
break; // Sai do loop para fazer o POST
40+
}
41+
}
42+
43+
// 2. Enviar comando (JSON-RPC) em outra thread/task ou conexão
44+
if (!string.IsNullOrEmpty(postUrl))
45+
{
46+
await CallTool(postUrl);
47+
}
48+
}
49+
}
50+
51+
static async Task CallTool(string url)
52+
{
53+
var client = new HttpClient();
54+
55+
string json = @"
56+
{
57+
""jsonrpc"": ""2.0"",
58+
""method"": ""tools/call"",
59+
""id"": 1,
60+
""params"": {
61+
""name"": ""cep_lookup"",
62+
""arguments"": {
63+
""cep"": ""01001000"",
64+
""bearer"": ""SEU_BEARER"",
65+
""deviceToken"": ""SEU_DEVICE_TOKEN""
66+
}
67+
}
68+
}";
69+
70+
var content = new StringContent(json, Encoding.UTF8, "application/json");
71+
var response = await client.PostAsync(url, content);
72+
73+
string result = await response.Content.ReadAsStringAsync();
74+
Console.WriteLine("\nResposta do Servidor:");
75+
Console.WriteLine(result);
76+
}
77+
}
78+
```

‎go/README.md‎

Lines changed: 85 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,85 @@
1+
# Consumindo APIBrasil MCP com Go (Golang)
2+
3+
Exemplo básico usando `net/http`.
4+
5+
## 1. Código (main.go)
6+
7+
```go
8+
package main
9+
10+
import (
11+
"bufio"
12+
"bytes"
13+
"encoding/json"
14+
"fmt"
15+
"net/http"
16+
"strings"
17+
)
18+
19+
const baseURL = "https://mcp.apibrasil.cloud/mcp"
20+
21+
func main() {
22+
fmt.Println("Conectando ao fluxo SSE...")
23+
24+
// 1. Iniciar SSE para pegar SessionID
25+
resp, err := http.Get(baseURL)
26+
if err != nil {
27+
panic(err)
28+
}
29+
defer resp.Body.Close()
30+
31+
scanner := bufio.NewScanner(resp.Body)
32+
var postURL string
33+
34+
// Loop simples para ler o evento 'endpoint'
35+
// Em produção, use uma lib SSE completa
36+
for scanner.Scan() {
37+
line := scanner.Text()
38+
fmt.Println("Recebido:", line)
39+
40+
if strings.HasPrefix(line, "data: ") {
41+
// O servidor manda o endpoint relativo no campo data
42+
endpoint := strings.TrimPrefix(line, "data: ")
43+
// Ajuste para montar URL completa
44+
if strings.HasPrefix(endpoint, "/") {
45+
// ex: /mcp?sessionId=xyz
46+
postURL = "https://mcp.apibrasil.cloud" + endpoint
47+
} else {
48+
postURL = endpoint
49+
}
50+
fmt.Println("Endpoint de POST detectado:", postURL)
51+
break // Temos o que precisamos para fazer chamadas
52+
}
53+
}
54+
55+
if postURL == "" {
56+
fmt.Println("Não foi possível obter SessionID.")
57+
return
58+
}
59+
60+
// 2. Fazer uma chamada de ferramenta (JSON-RPC)
61+
payload := map[string]interface{}{
62+
"jsonrpc": "2.0",
63+
"method": "tools/call",
64+
"id": 1,
65+
"params": map[string]interface{}{
66+
"name": "cep_lookup",
67+
"arguments": map[string]interface{}{
68+
"cep": "01001000",
69+
"bearer": "SEU_BEARER",
70+
"deviceToken": "SEU_DEVICE_TOKEN",
71+
},
72+
},
73+
}
74+
75+
jsonData, _ := json.Marshal(payload)
76+
postResp, err := http.Post(postURL, "application/json", bytes.NewBuffer(jsonData))
77+
if err != nil {
78+
panic(err)
79+
}
80+
defer postResp.Body.Close()
81+
82+
fmt.Println("Chamada enviada. Status:", postResp.Status)
83+
// Ler resposta...
84+
}
85+
```

‎java/README.md‎

Lines changed: 56 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,56 @@
1+
# Consumindo APIBrasil MCP com Java
2+
3+
Exemplo usando Java 11+ (HttpClient nativo). Como não há SDK oficial estável para Java ainda, fazemos a conexão SSE e POST manualmente seguindo o protocolo.
4+
5+
## 1. Código (McpClient.java)
6+
7+
```java
8+
import java.net.URI;
9+
import java.net.http.HttpClient;
10+
import java.net.http.HttpRequest;
11+
import java.net.http.HttpResponse;
12+
import java.util.concurrent.CompletableFuture;
13+
14+
public class McpClient {
15+
16+
private static final String SERVER_URL = "https://mcp.apibrasil.cloud/mcp";
17+
18+
// Tokens (Configure aqui)
19+
private static final String BEARER = "SEU_BEARER";
20+
private static final String DEVICE_TOKEN = "SEU_DEVICE_TOKEN";
21+
22+
public static void main(String[] args) {
23+
HttpClient client = HttpClient.newHttpClient();
24+
25+
// 1. Iniciar conexão SSE (GET)
26+
// Na prática, você precisaria de uma lib robusta de SSE para ler o stream continuamente.
27+
// Aqui simulamos o handshake inicial para pegar o Session ID.
28+
29+
System.out.println("Nota: Para produção, use uma biblioteca SSE como 'okhttp-sse' ou 'spring-webflux'.");
30+
System.out.println("Este exemplo mostra a lógica do protocolo.");
31+
32+
// Passo lógico:
33+
// 1. GET /mcp -> Recebe evento 'endpoint' com uri para POST (incluindo sessionId)
34+
// 2. POST /mcp?sessionId=... -> Envia JSON-RPC {"method": "tools/call", ...}
35+
36+
// Exemplo de Payload JSON-RPC para chamar a tool
37+
String jsonRpcPayload = "{"
38+
+ "\"jsonrpc\": \"2.0\","
39+
+ "\"method\": \"tools/call\","
40+
+ "\"id\": 1,"
41+
+ "\"params\": {"
42+
+ " \"name\": \"cep_lookup\","
43+
+ " \"arguments\": {"
44+
+ " \"cep\": \"01001000\","
45+
+ " \"bearer\": \"" + BEARER + "\","
46+
+ " \"deviceToken\": \"" + DEVICE_TOKEN + "\""
47+
+ " }"
48+
+ "}"
49+
+ "}";
50+
51+
System.out.println("Payload a enviar (após obter SessionID): " + jsonRpcPayload);
52+
}
53+
}
54+
```
55+
56+
**Dica:** Para projetos Java sérios, recomendamos usar o **Spring AI**, que está integrando suporte a MCP nativamente.

‎nodejs/README.md‎

Lines changed: 60 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,60 @@
1+
# Consumindo APIBrasil MCP com Node.js
2+
3+
Este exemplo usa o SDK oficial do MCP para TypeScript/Node.js.
4+
5+
## 1. Instalação
6+
7+
Abra seu terminal na pasta do projeto e instale as dependências:
8+
9+
```bash
10+
npm install @modelcontextprotocol/sdk eventsource
11+
```
12+
13+
## 2. Código (index.js ou index.ts)
14+
15+
```typescript
16+
import { Client } from "@modelcontextprotocol/sdk/client/index.js";
17+
import { SSEClientTransport } from "@modelcontextprotocol/sdk/client/sse.js";
18+
import { EventSource } from "eventsource";
19+
20+
// Polyfill para Node.js (necessário pois SSE usa EventSource do browser)
21+
global.EventSource = EventSource;
22+
23+
async function main() {
24+
// Configura a conexão com o servidor de produção
25+
const transport = new SSEClientTransport(
26+
new URL("https://mcp.apibrasil.cloud/mcp")
27+
);
28+
29+
const client = new Client(
30+
{ name: "meu-app-node", version: "1.0.0" },
31+
{ capabilities: { tools: {} } }
32+
);
33+
34+
console.log("Conectando...");
35+
await client.connect(transport);
36+
console.log("Conectado!");
37+
38+
// Lista ferramentas
39+
const { tools } = await client.listTools();
40+
console.log("Ferramentas disponíveis:", tools.map(t => t.name));
41+
42+
// Exemplo: Consultar CEP
43+
// Substitua pelos seus tokens reais
44+
try {
45+
const resultado = await client.callTool({
46+
name: "cep_lookup",
47+
arguments: {
48+
cep: "01001000",
49+
bearer: "SEU_BEARER_TOKEN",
50+
deviceToken: "SEU_DEVICE_TOKEN"
51+
}
52+
});
53+
console.log("Resultado:", JSON.stringify(resultado, null, 2));
54+
} catch (err) {
55+
console.error("Erro na chamada:", err.message);
56+
}
57+
}
58+
59+
main();
60+
```

‎python/README.md‎

Lines changed: 52 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,52 @@
1+
# Consumindo APIBrasil MCP com Python
2+
3+
Este exemplo usa o SDK oficial `mcp` para Python (asyncio).
4+
5+
## 1. Instalação
6+
7+
No seu ambiente virtual:
8+
9+
```bash
10+
pip install mcp
11+
```
12+
13+
## 2. Código (client.py)
14+
15+
```python
16+
import asyncio
17+
from mcp.client.sse import sse_client
18+
19+
async def main():
20+
url = "https://mcp.apibrasil.cloud/mcp"
21+
22+
print(f"Conectando a {url}...")
23+
24+
# Gerenciador de contexto conecta e desconecta automaticamente
25+
async with sse_client(url) as client:
26+
print("Conectado!")
27+
28+
# 1. Listar Ferramentas
29+
tools_result = await client.list_tools()
30+
print("\nFerramentas disponíveis:")
31+
for tool in tools_result.tools:
32+
print(f"- {tool.name}")
33+
34+
# 2. Chamar Ferramenta (Exemplo CEP)
35+
# Substitua pelos seus tokens
36+
try:
37+
result = await client.call_tool(
38+
name="cep_lookup",
39+
arguments={
40+
"cep": "01001000",
41+
"bearer": "SEU_BEARER_TOKEN",
42+
"deviceToken": "SEU_DEVICE_TOKEN"
43+
}
44+
)
45+
print("\nResultado da consulta:")
46+
print(result)
47+
except Exception as e:
48+
print(f"\nErro ao chamar ferramenta: {e}")
49+
50+
if __name__ == "__main__":
51+
asyncio.run(main())
52+
```

0 commit comments

Comments
 (0)