TypeScript
Primeiro, crie um novo diretório e inicialize seu projeto:
```bash
mkdir copilot-demo && cd copilot-demo
npm init -y --init-type module
```
Em seguida, instale o SDK e o executor typeScript:
```bash
npm install @github/copilot-sdk tsx
```
Python
```bash
pip install github-copilot-sdk
```
Go
Primeiro, crie um novo diretório e inicialize seu módulo:
```bash
mkdir copilot-demo && cd copilot-demo
go mod init copilot-demo
```
Em seguida, instale o SDK:
```bash
go get github.com/github/copilot-sdk/go
```
Rust
Primeiro, crie um novo crate binário:
```bash
cargo new copilot-demo && cd copilot-demo
```
Em seguida, instale o SDK e as dependências diretas usadas pelos exemplos:
```bash
cargo add github-copilot-sdk --features derive
# Used by #[tokio::main] and tokio::spawn
cargo add tokio --features rt-multi-thread,macros
# Used by custom-tool parameter derives later in this guide
cargo add serde --features derive
cargo add schemars
```
.NET
Primeiro, crie um novo projeto de console:
```bash
dotnet new console -n CopilotDemo && cd CopilotDemo
```
Em seguida, adicione o SDK:
```bash
dotnet add package GitHub.Copilot.SDK
```
Java
Primeiro, crie um novo diretório e inicialize seu projeto.
**Maven** – adicionar ao seu `pom.xml`:
```xml
com.github
copilot-sdk-java
${copilot.sdk.version}
```
**Gradle** — adicione ao seu `build.gradle`:
```groovy
implementation 'com.github:copilot-sdk-java:${copilotSdkVersion}'
```
## Etapa 2: enviar sua primeira mensagem
Crie um novo arquivo e adicione o código a seguir. Essa é a maneira mais simples de usar o SDK – cerca de 5 linhas de código.
TypeScript
Criar `index.ts`:
```typescript
import { CopilotClient } from "@github/copilot-sdk";
const client = new CopilotClient();
const session = await client.createSession({ model: "auto" });
const response = await session.sendAndWait({ prompt: "What is 2 + 2?" });
console.log(response?.data.content);
await client.stop();
process.exit(0);
```
Execute-o:
```bash
npx tsx index.ts
```
Python
Criar `main.py`:
```python
import asyncio
from copilot import CopilotClient
from copilot.session import PermissionHandler
async def main():
client = CopilotClient()
await client.start()
session = await client.create_session(on_permission_request=PermissionHandler.approve_all, model="auto")
response = await session.send_and_wait("What is 2 + 2?")
print(response.data.content)
await client.stop()
asyncio.run(main())
```
Execute-o:
```bash
python main.py
```
Go
Criar `main.go`:
```golang
package main
import (
"context"
"fmt"
"log"
"os"
copilot "github.com/github/copilot-sdk/go"
)
func main() {
ctx := context.Background()
client := copilot.NewClient(nil)
if err := client.Start(ctx); err != nil {
log.Fatal(err)
}
defer client.Stop()
session, err := client.CreateSession(ctx, &copilot.SessionConfig{Model: "auto"})
if err != nil {
log.Fatal(err)
}
response, err := session.SendAndWait(ctx, copilot.MessageOptions{Prompt: "What is 2 + 2?"})
if err != nil {
log.Fatal(err)
}
if d, ok := response.Data.(*copilot.AssistantMessageData); ok {
fmt.Println(d.Content)
}
os.Exit(0)
}
```
Execute-o:
```bash
go run main.go
```
Rust
Criar `src/main.rs`:
```rust
use std::sync::Arc;
use std::time::Duration;
use github_copilot_sdk::handler::ApproveAllHandler;
use github_copilot_sdk::{Client, ClientOptions, MessageOptions, SessionConfig};
#[tokio::main]
async fn main() -> Result<(), Box
> {
let client = Client::start(ClientOptions::default()).await?;
let session = client
.create_session(SessionConfig::default().with_permission_handler(Arc::new(ApproveAllHandler)))
.await?;
let response = session
.send_and_wait(
MessageOptions::new("What is 2 + 2?").with_wait_timeout(Duration::from_secs(120)),
)
.await?;
if let Some(event) = response {
if let Some(content) = event.data.get("content").and_then(|value| value.as_str()) {
println!("{content}");
}
}
session.disconnect().await?;
client.stop().await?;
Ok(())
}
```
Execute-o:
```bash
cargo run
```
.NET
Crie um novo projeto de console e adicione-o a `Program.cs`:
```csharp
using GitHub.Copilot;
await using var client = new CopilotClient();
await using var session = await client.CreateSessionAsync(new SessionConfig
{
Model = "auto",
OnPermissionRequest = PermissionHandler.ApproveAll
});
var response = await session.SendAndWaitAsync(new MessageOptions { Prompt = "What is 2 + 2?" });
Console.WriteLine(response?.Data.Content);
```
Execute-o:
```bash
dotnet run
```
Java
Criar `HelloCopilot.java`:
```java
import com.github.copilot.CopilotClient;
import com.github.copilot.rpc.*;
public class HelloCopilot {
public static void main(String[] args) throws Exception {
try (var client = new CopilotClient()) {
client.start().get();
var session = client.createSession(
new SessionConfig()
.setModel("auto")
.setOnPermissionRequest(PermissionHandler.APPROVE_ALL)
).get();
var response = session.sendAndWait(
new MessageOptions().setPrompt("What is 2 + 2?")
).get();
System.out.println(response.getData().content());
client.stop().get();
}
}
}
```
Execute-o:
```bash
javac -cp copilot-sdk.jar HelloCopilot.java && java -cp .:copilot-sdk.jar HelloCopilot
```
**Você deve ver:**
```text
4
```
Parabéns! Você acabou de criar seu primeiro aplicativo com tecnologia Copilot.
## Etapa 3: adicionar respostas de streaming
No momento, aguarde a resposta completa antes de ver qualquer coisa. Vamos torná-la interativa transmitindo a resposta conforme ela é gerada.
TypeScript
Atualização `index.ts`:
```typescript
import { CopilotClient } from "@github/copilot-sdk";
const client = new CopilotClient();
const session = await client.createSession({
model: "auto",
streaming: true,
});
// Listen for response chunks
session.on("assistant.message_delta", (event) => {
process.stdout.write(event.data.deltaContent);
});
session.on("session.idle", () => {
console.log(); // New line when done
});
await session.sendAndWait({ prompt: "Tell me a short joke" });
await client.stop();
process.exit(0);
```
Python
Atualização `main.py`:
```python
import asyncio
import sys
from copilot import CopilotClient
from copilot.session import PermissionHandler
from copilot.session_events import SessionEventType
async def main():
client = CopilotClient()
await client.start()
session = await client.create_session(on_permission_request=PermissionHandler.approve_all, model="auto", streaming=True)
# Listen for response chunks
def handle_event(event):
if event.type == SessionEventType.ASSISTANT_MESSAGE_DELTA:
sys.stdout.write(event.data.delta_content)
sys.stdout.flush()
if event.type == SessionEventType.SESSION_IDLE:
print() # New line when done
session.on(handle_event)
await session.send_and_wait("Tell me a short joke")
await client.stop()
asyncio.run(main())
```
Go
Atualização `main.go`:
```golang
package main
import (
"context"
"fmt"
"log"
"os"
copilot "github.com/github/copilot-sdk/go"
)
func main() {
ctx := context.Background()
client := copilot.NewClient(nil)
if err := client.Start(ctx); err != nil {
log.Fatal(err)
}
defer client.Stop()
session, err := client.CreateSession(ctx, &copilot.SessionConfig{
Model: "auto",
Streaming: copilot.Bool(true),
})
if err != nil {
log.Fatal(err)
}
// Listen for response chunks
session.On(func(event copilot.SessionEvent) {
switch d := event.Data.(type) {
case *copilot.AssistantMessageDeltaData:
fmt.Print(d.DeltaContent)
case *copilot.SessionIdleData:
_ = d
fmt.Println()
}
})
_, err = session.SendAndWait(ctx, copilot.MessageOptions{Prompt: "Tell me a short joke"})
if err != nil {
log.Fatal(err)
}
os.Exit(0)
}
```
Rust
Atualização `src/main.rs`:
```rust
use std::io::{self, Write};
use std::sync::Arc;
use std::time::Duration;
use github_copilot_sdk::handler::ApproveAllHandler;
use github_copilot_sdk::{Client, ClientOptions, MessageOptions, SessionConfig};
#[tokio::main]
async fn main() -> Result<(), Box
> {
let client = Client::start(ClientOptions::default()).await?;
let mut config = SessionConfig::default();
config.streaming = Some(true);
let session = client
.create_session(config.with_permission_handler(Arc::new(ApproveAllHandler)))
.await?;
// Listen for response chunks
let mut events = session.subscribe();
tokio::spawn(async move {
while let Ok(event) = events.recv().await {
match event.event_type.as_str() {
"assistant.message_delta" => {
if let Some(text) =
event.data.get("deltaContent").and_then(|value| value.as_str())
{
print!("{text}");
io::stdout().flush().ok();
}
}
"assistant.message" => println!(),
_ => {}
}
}
});
session
.send_and_wait(
MessageOptions::new("Tell me a short joke")
.with_wait_timeout(Duration::from_secs(120)),
)
.await?;
session.disconnect().await?;
client.stop().await?;
Ok(())
}
```
.NET
Atualização `Program.cs`:
```csharp
using GitHub.Copilot;
await using var client = new CopilotClient();
await using var session = await client.CreateSessionAsync(new SessionConfig
{
Model = "auto",
OnPermissionRequest = PermissionHandler.ApproveAll,
Streaming = true,
});
// Listen for response chunks
session.On
(ev =>
{
if (ev is AssistantMessageDeltaEvent deltaEvent)
{
Console.Write(deltaEvent.Data.DeltaContent);
}
if (ev is SessionIdleEvent)
{
Console.WriteLine();
}
});
await session.SendAndWaitAsync(new MessageOptions { Prompt = "Tell me a short joke" });
```
Java
Atualização `HelloCopilot.java`:
```java
import com.github.copilot.CopilotClient;
import com.github.copilot.rpc.*;
public class HelloCopilot {
public static void main(String[] args) throws Exception {
try (var client = new CopilotClient()) {
client.start().get();
var session = client.createSession(
new SessionConfig()
.setModel("auto")
.setStreaming(true)
.setOnPermissionRequest(PermissionHandler.APPROVE_ALL)
).get();
// Listen for response chunks
session.on(AssistantMessageDeltaEvent.class, delta -> {
System.out.print(delta.getData().deltaContent());
});
session.on(SessionIdleEvent.class, idle -> {
System.out.println(); // New line when done
});
session.sendAndWait(
new MessageOptions().setPrompt("Tell me a short joke")
).get();
client.stop().get();
}
}
}
```
Execute o código novamente. Você verá a resposta aparecer palavra por palavra.
### Métodos de assinatura de evento
O SDK fornece métodos para assinar eventos de sessão:
| Método | Description |
| ------------------------ | --------------------------------------------------------------------------------------------------------------------- |
| `on(handler)` | Inscreva-se em todos os eventos; retorna a função de cancelamento de assinatura |
| `on(eventType, handler)` | Inscrever-se em um tipo específico de evento (somente Node.js/TypeScript); retorna a função para cancelar a inscrição |
| `subscribe()` | Assinar todos os eventos (Rust); filtrar por `event_type` |
TypeScript
```typescript
// Subscribe to all events
const unsubscribeAll = session.on((event) => {
console.log("Event:", event.type);
});
// Subscribe to specific event type
const unsubscribeIdle = session.on("session.idle", (event) => {
console.log("Session is idle");
});
// Later, to unsubscribe:
unsubscribeAll();
unsubscribeIdle();
```
Python
```python
# Subscribe to all events
unsubscribe = session.on(lambda event: print(f"Event: {event.type}"))
# Filter by event type in your handler
def handle_event(event):
if event.type == SessionEventType.SESSION_IDLE:
print("Session is idle")
elif event.type == SessionEventType.ASSISTANT_MESSAGE:
print(f"Message: {event.data.content}")
unsubscribe = session.on(handle_event)
# Later, to unsubscribe:
unsubscribe()
```
Go
```golang
// Subscribe to all events
unsubscribe := session.On(func(event copilot.SessionEvent) {
fmt.Println("Event:", event.Type)
})
// Filter by event type in your handler
session.On(func(event copilot.SessionEvent) {
switch d := event.Data.(type) {
case *copilot.SessionIdleData:
_ = d
fmt.Println("Session is idle")
case *copilot.AssistantMessageData:
fmt.Println("Message:", d.Content)
}
})
// Later, to unsubscribe:
unsubscribe()
```
Rust
```rust
let mut events = session.subscribe();
tokio::spawn(async move {
while let Ok(event) = events.recv().await {
println!("Event: {}", event.event_type);
match event.event_type.as_str() {
"session.idle" => println!("Session is idle"),
"assistant.message" => {
if let Some(content) = event.data.get("content").and_then(|value| value.as_str()) {
println!("Message: {content}");
}
}
_ => {}
}
}
});
```
.NET
```csharp
// Subscribe to all events
var unsubscribe = session.On
(ev => Console.WriteLine($"Event: {ev.Type}"));
// Filter by event type using pattern matching
session.On(ev =>
{
switch (ev)
{
case SessionIdleEvent:
Console.WriteLine("Session is idle");
break;
case AssistantMessageEvent msg:
Console.WriteLine($"Message: {msg.Data.Content}");
break;
}
});
// Later, to unsubscribe:
unsubscribe.Dispose();
```
Java
```java
// Subscribe to all events
var unsubscribe = session.on(event -> {
System.out.println("Event: " + event.getType());
});
// Subscribe to a specific event type
session.on(AssistantMessageEvent.class, msg -> {
System.out.println("Message: " + msg.getData().content());
});
session.on(SessionIdleEvent.class, idle -> {
System.out.println("Session is idle");
});
// Later, to unsubscribe:
unsubscribe.close();
```
## Etapa 4: adicionar uma ferramenta personalizada
Agora, a parte mais poderosa. Vamos dar a Copilot a capacidade de chamar seu código definindo uma ferramenta personalizada. Criaremos uma ferramenta de pesquisa de clima simples.
TypeScript
Atualização `index.ts`:
```typescript
import { CopilotClient, defineTool } from "@github/copilot-sdk";
// Define a tool that Copilot can call
const getWeather = defineTool("get_weather", {
description: "Get the current weather for a city",
parameters: {
type: "object",
properties: {
city: { type: "string", description: "The city name" },
},
required: ["city"],
},
handler: async (args: { city: string }) => {
const { city } = args;
// In a real app, you'd call a weather API here
const conditions = ["sunny", "cloudy", "rainy", "partly cloudy"];
const temp = Math.floor(Math.random() * 30) + 50;
const condition = conditions[Math.floor(Math.random() * conditions.length)];
return { city, temperature: `${temp}°F`, condition };
},
});
const client = new CopilotClient();
const session = await client.createSession({
model: "auto",
streaming: true,
tools: [getWeather],
});
session.on("assistant.message_delta", (event) => {
process.stdout.write(event.data.deltaContent);
});
session.on("session.idle", () => {
console.log(); // New line when done
});
await session.sendAndWait({
prompt: "What's the weather like in Seattle and Tokyo?",
});
await client.stop();
process.exit(0);
```
Python
Atualização `main.py`:
```python
import asyncio
import random
import sys
from copilot import CopilotClient
from copilot.session import PermissionHandler
from copilot.tools import define_tool
from copilot.session_events import SessionEventType
from pydantic import BaseModel, Field
# Define the parameters for the tool using Pydantic
class GetWeatherParams(BaseModel):
city: str = Field(description="The name of the city to get weather for")
# Define a tool that Copilot can call
@define_tool(description="Get the current weather for a city")
async def get_weather(params: GetWeatherParams) -> dict:
city = params.city
# In a real app, you'd call a weather API here
conditions = ["sunny", "cloudy", "rainy", "partly cloudy"]
temp = random.randint(50, 80)
condition = random.choice(conditions)
return {"city": city, "temperature": f"{temp}°F", "condition": condition}
async def main():
client = CopilotClient()
await client.start()
session = await client.create_session(on_permission_request=PermissionHandler.approve_all, model="auto", streaming=True, tools=[get_weather])
def handle_event(event):
if event.type == SessionEventType.ASSISTANT_MESSAGE_DELTA:
sys.stdout.write(event.data.delta_content)
sys.stdout.flush()
if event.type == SessionEventType.SESSION_IDLE:
print()
session.on(handle_event)
await session.send_and_wait("What's the weather like in Seattle and Tokyo?")
await client.stop()
asyncio.run(main())
```
Go
Atualização `main.go`:
```golang
package main
import (
"context"
"fmt"
"log"
"math/rand"
"os"
copilot "github.com/github/copilot-sdk/go"
)
// Define the parameter type
type WeatherParams struct {
City string `json:"city" jsonschema:"The city name"`
}
// Define the return type
type WeatherResult struct {
City string `json:"city"`
Temperature string `json:"temperature"`
Condition string `json:"condition"`
}
func main() {
ctx := context.Background()
// Define a tool that Copilot can call
getWeather := copilot.DefineTool(
"get_weather",
"Get the current weather for a city",
func(params WeatherParams, inv copilot.ToolInvocation) (WeatherResult, error) {
// In a real app, you'd call a weather API here
conditions := []string{"sunny", "cloudy", "rainy", "partly cloudy"}
temp := rand.Intn(30) + 50
condition := conditions[rand.Intn(len(conditions))]
return WeatherResult{
City: params.City,
Temperature: fmt.Sprintf("%d°F", temp),
Condition: condition,
}, nil
},
)
client := copilot.NewClient(nil)
if err := client.Start(ctx); err != nil {
log.Fatal(err)
}
defer client.Stop()
session, err := client.CreateSession(ctx, &copilot.SessionConfig{
Model: "auto",
Streaming: copilot.Bool(true),
Tools: []copilot.Tool{getWeather},
})
if err != nil {
log.Fatal(err)
}
session.On(func(event copilot.SessionEvent) {
switch d := event.Data.(type) {
case *copilot.AssistantMessageDeltaData:
fmt.Print(d.DeltaContent)
case *copilot.SessionIdleData:
_ = d
fmt.Println()
}
})
_, err = session.SendAndWait(ctx, copilot.MessageOptions{
Prompt: "What's the weather like in Seattle and Tokyo?",
})
if err != nil {
log.Fatal(err)
}
os.Exit(0)
}
```
Rust
Atualização `src/main.rs`:
```rust
use std::io::{self, Write};
use std::sync::Arc;
use std::time::Duration;
use github_copilot_sdk::handler::ApproveAllHandler;
use github_copilot_sdk::tool::{define_tool, JsonSchema};
use github_copilot_sdk::{Client, ClientOptions, MessageOptions, SessionConfig, ToolResult};
use serde::Deserialize;
#[derive(Deserialize, JsonSchema)]
struct GetWeatherParams {
city: String,
}
#[tokio::main]
async fn main() -> Result<(), Box
> {
// Define a tool that Copilot can call
let tools = vec![define_tool(
"get_weather",
"Get the current weather for a city",
|_inv, params: GetWeatherParams| async move {
Ok(ToolResult::Text(format!(
"{}: 62°F and sunny",
params.city
)))
},
)];
let client = Client::start(ClientOptions::default()).await?;
let mut config = SessionConfig::default();
config.streaming = Some(true);
let session = client
.create_session(
config
.with_tools(tools)
.with_permission_handler(Arc::new(ApproveAllHandler)),
)
.await?;
let mut events = session.subscribe();
tokio::spawn(async move {
while let Ok(event) = events.recv().await {
match event.event_type.as_str() {
"assistant.message_delta" => {
if let Some(text) =
event.data.get("deltaContent").and_then(|value| value.as_str())
{
print!("{text}");
io::stdout().flush().ok();
}
}
"assistant.message" => println!(),
_ => {}
}
}
});
session
.send_and_wait(
MessageOptions::new("What's the weather like in Seattle and Tokyo?")
.with_wait_timeout(Duration::from_secs(120)),
)
.await?;
session.disconnect().await?;
client.stop().await?;
Ok(())
}
```
.NET
Atualização `Program.cs`:
```csharp
using GitHub.Copilot;
using Microsoft.Extensions.AI;
using System.ComponentModel;
await using var client = new CopilotClient();
// Define a tool that Copilot can call
var getWeather = CopilotTool.DefineTool(
([Description("The city name")] string city) =>
{
// In a real app, you'd call a weather API here
var conditions = new[] { "sunny", "cloudy", "rainy", "partly cloudy" };
var temp = Random.Shared.Next(50, 80);
var condition = conditions[Random.Shared.Next(conditions.Length)];
return new { city, temperature = $"{temp}°F", condition };
},
factoryOptions: new AIFunctionFactoryOptions
{
Name = "get_weather",
Description = "Get the current weather for a city",
}
);
await using var session = await client.CreateSessionAsync(new SessionConfig
{
Model = "auto",
OnPermissionRequest = PermissionHandler.ApproveAll,
Streaming = true,
Tools = [getWeather],
});
session.On
(ev =>
{
if (ev is AssistantMessageDeltaEvent deltaEvent)
{
Console.Write(deltaEvent.Data.DeltaContent);
}
if (ev is SessionIdleEvent)
{
Console.WriteLine();
}
});
await session.SendAndWaitAsync(new MessageOptions
{
Prompt = "What's the weather like in Seattle and Tokyo?",
});
```
Java
Atualização `HelloCopilot.java`:
```java
import com.github.copilot.CopilotClient;
import com.github.copilot.rpc.*;
import java.util.List;
import java.util.Map;
import java.util.Random;
import java.util.concurrent.CompletableFuture;
public class HelloCopilot {
public static void main(String[] args) throws Exception {
var random = new Random();
var conditions = List.of("sunny", "cloudy", "rainy", "partly cloudy");
// Define a tool that Copilot can call
var getWeather = ToolDefinition.create(
"get_weather",
"Get the current weather for a city",
Map.of(
"type", "object",
"properties", Map.of(
"city", Map.of("type", "string", "description", "The city name")
),
"required", List.of("city")
),
invocation -> {
var city = (String) invocation.getArguments().get("city");
var temp = random.nextInt(30) + 50;
var condition = conditions.get(random.nextInt(conditions.size()));
return CompletableFuture.completedFuture(Map.of(
"city", city,
"temperature", temp + "°F",
"condition", condition
));
}
);
try (var client = new CopilotClient()) {
client.start().get();
var session = client.createSession(
new SessionConfig()
.setModel("auto")
.setStreaming(true)
.setTools(List.of(getWeather))
.setOnPermissionRequest(PermissionHandler.APPROVE_ALL)
).get();
session.on(AssistantMessageDeltaEvent.class, delta -> {
System.out.print(delta.getData().deltaContent());
});
session.on(SessionIdleEvent.class, idle -> {
System.out.println();
});
session.sendAndWait(
new MessageOptions().setPrompt("What's the weather like in Seattle and Tokyo?")
).get();
client.stop().get();
}
}
}
```
Execute-o e você verá Copilot chamar sua ferramenta para obter dados meteorológicos e responder com os resultados!
## Etapa 5: criar um assistente interativo
Vamos juntar tudo em um assistente interativo útil:
TypeScript
```typescript
import { CopilotClient, defineTool } from "@github/copilot-sdk";
import * as readline from "readline";
const getWeather = defineTool("get_weather", {
description: "Get the current weather for a city",
parameters: {
type: "object",
properties: {
city: { type: "string", description: "The city name" },
},
required: ["city"],
},
handler: async ({ city }) => {
const conditions = ["sunny", "cloudy", "rainy", "partly cloudy"];
const temp = Math.floor(Math.random() * 30) + 50;
const condition = conditions[Math.floor(Math.random() * conditions.length)];
return { city, temperature: `${temp}°F`, condition };
},
});
const client = new CopilotClient();
const session = await client.createSession({
model: "auto",
streaming: true,
tools: [getWeather],
});
session.on("assistant.message_delta", (event) => {
process.stdout.write(event.data.deltaContent);
});
const rl = readline.createInterface({
input: process.stdin,
output: process.stdout,
});
console.log("🌤️ Weather Assistant (type 'exit' to quit)");
console.log(" Try: 'What's the weather in Paris?'\n");
const prompt = () => {
rl.question("You: ", async (input) => {
if (input.toLowerCase() === "exit") {
await client.stop();
rl.close();
return;
}
process.stdout.write("Assistant: ");
await session.sendAndWait({ prompt: input });
console.log("\n");
prompt();
});
};
prompt();
```
Execute com:
```bash
npx tsx weather-assistant.ts
```
Python
Criar `weather_assistant.py`:
```python
import asyncio
import random
import sys
from copilot import CopilotClient
from copilot.session import PermissionHandler
from copilot.tools import define_tool
from copilot.session_events import SessionEventType
from pydantic import BaseModel, Field
class GetWeatherParams(BaseModel):
city: str = Field(description="The name of the city to get weather for")
@define_tool(description="Get the current weather for a city")
async def get_weather(params: GetWeatherParams) -> dict:
city = params.city
conditions = ["sunny", "cloudy", "rainy", "partly cloudy"]
temp = random.randint(50, 80)
condition = random.choice(conditions)
return {"city": city, "temperature": f"{temp}°F", "condition": condition}
async def main():
client = CopilotClient()
await client.start()
session = await client.create_session(on_permission_request=PermissionHandler.approve_all, model="auto", streaming=True, tools=[get_weather])
def handle_event(event):
if event.type == SessionEventType.ASSISTANT_MESSAGE_DELTA:
sys.stdout.write(event.data.delta_content)
sys.stdout.flush()
session.on(handle_event)
print("🌤️ Weather Assistant (type 'exit' to quit)")
print(" Try: 'What's the weather in Paris?' or 'Compare weather in NYC and LA'\n")
while True:
try:
user_input = input("You: ")
except EOFError:
break
if user_input.lower() == "exit":
break
sys.stdout.write("Assistant: ")
await session.send_and_wait(user_input)
print("\n")
await client.stop()
asyncio.run(main())
```
Execute com:
```bash
python weather_assistant.py
```
Go
Criar `weather-assistant.go`:
```golang
package main
import (
"bufio"
"context"
"fmt"
"log"
"math/rand"
"os"
"strings"
copilot "github.com/github/copilot-sdk/go"
)
type WeatherParams struct {
City string `json:"city" jsonschema:"The city name"`
}
type WeatherResult struct {
City string `json:"city"`
Temperature string `json:"temperature"`
Condition string `json:"condition"`
}
func main() {
ctx := context.Background()
getWeather := copilot.DefineTool(
"get_weather",
"Get the current weather for a city",
func(params WeatherParams, inv copilot.ToolInvocation) (WeatherResult, error) {
conditions := []string{"sunny", "cloudy", "rainy", "partly cloudy"}
temp := rand.Intn(30) + 50
condition := conditions[rand.Intn(len(conditions))]
return WeatherResult{
City: params.City,
Temperature: fmt.Sprintf("%d°F", temp),
Condition: condition,
}, nil
},
)
client := copilot.NewClient(nil)
if err := client.Start(ctx); err != nil {
log.Fatal(err)
}
defer client.Stop()
session, err := client.CreateSession(ctx, &copilot.SessionConfig{
Model: "auto",
Streaming: copilot.Bool(true),
Tools: []copilot.Tool{getWeather},
})
if err != nil {
log.Fatal(err)
}
session.On(func(event copilot.SessionEvent) {
switch d := event.Data.(type) {
case *copilot.AssistantMessageDeltaData:
fmt.Print(d.DeltaContent)
case *copilot.SessionIdleData:
_ = d
fmt.Println()
}
})
fmt.Println("🌤️ Weather Assistant (type 'exit' to quit)")
fmt.Println(" Try: 'What's the weather in Paris?' or 'Compare weather in NYC and LA'\n")
scanner := bufio.NewScanner(os.Stdin)
for {
fmt.Print("You: ")
if !scanner.Scan() {
break
}
input := scanner.Text()
if strings.ToLower(input) == "exit" {
break
}
fmt.Print("Assistant: ")
_, err = session.SendAndWait(ctx, copilot.MessageOptions{Prompt: input})
if err != nil {
fmt.Fprintf(os.Stderr, "Error: %v\n", err)
break
}
fmt.Println()
}
if err := scanner.Err(); err != nil {
fmt.Fprintf(os.Stderr, "Input error: %v\n", err)
}
}
```
Execute com:
```bash
go run weather-assistant.go
```
Rust
Criar `src/main.rs`:
```rust
use std::io::{self, BufRead, Write};
use std::sync::Arc;
use std::time::Duration;
use github_copilot_sdk::handler::ApproveAllHandler;
use github_copilot_sdk::tool::{define_tool, JsonSchema};
use github_copilot_sdk::{Client, ClientOptions, MessageOptions, SessionConfig, ToolResult};
use serde::Deserialize;
#[derive(Deserialize, JsonSchema)]
struct GetWeatherParams {
city: String,
}
fn read_line() -> Option
{
let stdin = io::stdin();
let mut line = String::new();
stdin.lock().read_line(&mut line).ok()?;
if line.is_empty() {
return None;
}
Some(line.trim_end_matches(&['\n', '\r'][..]).to_string())
}
#[tokio::main]
async fn main() -> Result<(), Box> {
let tools = vec![define_tool(
"get_weather",
"Get the current weather for a city",
|_inv, params: GetWeatherParams| async move {
Ok(ToolResult::Text(format!(
"{}: 62°F and sunny",
params.city
)))
},
)];
let client = Client::start(ClientOptions::default()).await?;
let mut config = SessionConfig::default();
config.streaming = Some(true);
let session = client
.create_session(
config
.with_tools(tools)
.with_permission_handler(Arc::new(ApproveAllHandler)),
)
.await?;
let mut events = session.subscribe();
tokio::spawn(async move {
while let Ok(event) = events.recv().await {
match event.event_type.as_str() {
"assistant.message_delta" => {
if let Some(text) =
event.data.get("deltaContent").and_then(|value| value.as_str())
{
print!("{text}");
io::stdout().flush().ok();
}
}
"assistant.message" => println!(),
_ => {}
}
}
});
println!("Weather Assistant (type 'exit' to quit)");
println!("Try: 'What's the weather in Paris?' or 'Compare weather in NYC and LA'\n");
loop {
print!("You: ");
io::stdout().flush().ok();
let Some(input) = read_line() else { break };
if input.eq_ignore_ascii_case("exit") {
break;
}
print!("Assistant: ");
io::stdout().flush().ok();
session
.send_and_wait(MessageOptions::new(input).with_wait_timeout(Duration::from_secs(120)))
.await?;
println!();
}
session.disconnect().await?;
client.stop().await?;
Ok(())
}
```
Execute com:
```bash
cargo run
```
.NET
Crie um novo projeto de console e atualize `Program.cs`:
```csharp
using GitHub.Copilot;
using Microsoft.Extensions.AI;
using System.ComponentModel;
// Define the weather tool
var getWeather = CopilotTool.DefineTool(
([Description("The city name")] string city) =>
{
var conditions = new[] { "sunny", "cloudy", "rainy", "partly cloudy" };
var temp = Random.Shared.Next(50, 80);
var condition = conditions[Random.Shared.Next(conditions.Length)];
return new { city, temperature = $"{temp}°F", condition };
},
factoryOptions: new AIFunctionFactoryOptions
{
Name = "get_weather",
Description = "Get the current weather for a city",
});
await using var client = new CopilotClient();
await using var session = await client.CreateSessionAsync(new SessionConfig
{
Model = "auto",
OnPermissionRequest = PermissionHandler.ApproveAll,
Streaming = true,
Tools = [getWeather]
});
// Listen for response chunks
session.On
(ev =>
{
if (ev is AssistantMessageDeltaEvent deltaEvent)
{
Console.Write(deltaEvent.Data.DeltaContent);
}
if (ev is SessionIdleEvent)
{
Console.WriteLine();
}
});
Console.WriteLine("🌤️ Weather Assistant (type 'exit' to quit)");
Console.WriteLine(" Try: 'What's the weather in Paris?' or 'Compare weather in NYC and LA'\n");
while (true)
{
Console.Write("You: ");
var input = Console.ReadLine();
if (string.IsNullOrEmpty(input) || input.Equals("exit", StringComparison.OrdinalIgnoreCase))
{
break;
}
Console.Write("Assistant: ");
await session.SendAndWaitAsync(new MessageOptions { Prompt = input });
Console.WriteLine("\n");
}
```
Execute com:
```bash
dotnet run
```
Java
Criar `WeatherAssistant.java`:
```java
import com.github.copilot.CopilotClient;
import com.github.copilot.rpc.*;
import java.util.List;
import java.util.Map;
import java.util.Random;
import java.util.Scanner;
import java.util.concurrent.CompletableFuture;
public class WeatherAssistant {
public static void main(String[] args) throws Exception {
var random = new Random();
var conditions = List.of("sunny", "cloudy", "rainy", "partly cloudy");
var getWeather = ToolDefinition.create(
"get_weather",
"Get the current weather for a city",
Map.of(
"type", "object",
"properties", Map.of(
"city", Map.of("type", "string", "description", "The city name")
),
"required", List.of("city")
),
invocation -> {
var city = (String) invocation.getArguments().get("city");
var temp = random.nextInt(30) + 50;
var condition = conditions.get(random.nextInt(conditions.size()));
return CompletableFuture.completedFuture(Map.of(
"city", city,
"temperature", temp + "°F",
"condition", condition
));
}
);
try (var client = new CopilotClient()) {
client.start().get();
var session = client.createSession(
new SessionConfig()
.setModel("auto")
.setStreaming(true)
.setOnPermissionRequest(request ->
CompletableFuture.completedFuture(PermissionDecision.allow())
)
.setTools(List.of(getWeather))
).get();
session.on(AssistantMessageDeltaEvent.class, delta -> {
System.out.print(delta.getData().deltaContent());
});
session.on(SessionIdleEvent.class, idle -> {
System.out.println();
});
System.out.println("🌤️ Weather Assistant (type 'exit' to quit)");
System.out.println(" Try: 'What's the weather in Paris?' or 'Compare weather in NYC and LA'\n");
var scanner = new Scanner(System.in);
while (true) {
System.out.print("You: ");
if (!scanner.hasNextLine()) break;
var input = scanner.nextLine();
if (input.equalsIgnoreCase("exit")) break;
System.out.print("Assistant: ");
session.sendAndWait(
new MessageOptions().setPrompt(input)
).get();
System.out.println("\n");
}
client.stop().get();
}
}
}
```
Execute com:
```bash
javac -cp copilot-sdk.jar WeatherAssistant.java && java -cp .:copilot-sdk.jar WeatherAssistant
```
**Sessão de exemplo:**
```text
🌤️ Weather Assistant (type 'exit' to quit)
Try: 'What's the weather in Paris?' or 'Compare weather in NYC and LA'
You: What's the weather in Seattle?
Assistant: Let me check the weather for Seattle...
It's currently 62°F and cloudy in Seattle.
You: How about Tokyo and London?
Assistant: I'll check both cities for you:
- Tokyo: 75°F and sunny
- London: 58°F and rainy
You: exit
```
Você criou um assistente com uma ferramenta personalizada que Copilot pode chamar!
## Como as ferramentas funcionam
Ao definir uma ferramenta, você informa Copilot:
1. **O que a ferramenta faz** (descrição)
2. **Quais parâmetros ele precisa** (esquema)
3. **Que código executar** (manipulador)
Copilot decide quando chamar sua ferramenta com base na pergunta do usuário. Quando isso acontecer:
1. Copilot envia uma solicitação de chamada de ferramenta com os parâmetros
2. O SDK executa sua função de manipulador
3. O resultado é enviado de volta para Copilot
4. Copilot incorpora o resultado em sua resposta
## E agora?
Agora que você tem as noções básicas, aqui estão os recursos mais poderosos a serem explorados:
### Conectar-se a servidores MCP
Os servidores MCP (Protocolo de Contexto de Modelo) oferecem ferramentas pré-construídas. Conecte-se ao servidor MCP do GitHub para dar acesso Copilot a repositórios, problemas e solicitações de pull:
```typescript
const session = await client.createSession({
mcpServers: {
github: {
type: "http",
url: "https://api.githubcopilot.com/mcp/",
},
},
});
```
📖
\*\*
[Usando servidores MCP com o SDK do GitHub Copilot](/pt/enterprise-cloud@latest/copilot/how-tos/copilot-sdk/features/mcp)\*\* - Saiba mais sobre servidores locais versus remotos, todas as opções de configuração e solução de problemas.
### Criar agentes personalizados
Defina personas de IA especializadas para tarefas específicas:
```typescript
const session = await client.createSession({
customAgents: [{
name: "pr-reviewer",
displayName: "PR Reviewer",
description: "Reviews pull requests for best practices",
prompt: "You are an expert code reviewer. Focus on security, performance, and maintainability.",
}],
});
```
> \[!TIP]
> Você também pode definir `agent: "pr-reviewer"` na configuração da sessão para pré-selecionar esse agente desde o início. Consulte o [Agentes personalizados e orquestração de subagentes](/pt/enterprise-cloud@latest/copilot/how-tos/copilot-sdk/features/custom-agents#selecting-an-agent-at-session-creation) para obter detalhes.
### Personalizar a mensagem do sistema
Controle o comportamento e a personalidade da IA acrescentando instruções:
```typescript
const session = await client.createSession({
systemMessage: {
content: "You are a helpful assistant for our engineering team. Always be concise.",
},
});
```
Para um controle mais refinado, use `mode: "customize"` para substituir seções individuais do prompt do sistema, preservando o restante:
```typescript
const session = await client.createSession({
systemMessage: {
mode: "customize",
sections: {
tone: { action: "replace", content: "Respond in a warm, professional tone. Be thorough in explanations." },
code_change_rules: { action: "remove" },
guidelines: { action: "append", content: "\n* Always cite data sources" },
},
content: "Focus on financial analysis and reporting.",
},
});
```
IDs de seção disponíveis: `preamble`, , `identity`, `tone`, `tool_efficiency`, `environment_context`, `code_change_rules`, `guidelines`, , `safety`, `tool_instructions`, , `custom_instructions`, , , `runtime_instructions``last_instructions`.
`identity` e `tool_instructions` são *grupos* de seções: eles têm como destino uma coleção de subseções relacionadas como uma unidade. Use `preamble` para direcionar apenas o preâmbulo de identidade sem afetar suas respectivas subseções irmãs.
Cada substituição oferece suporte a cinco ações: `replace`, `remove`, `append`, `prepend` e `preserve`. A ação `preserve` é uma operação sem efeito que exclui uma seção endereçável individualmente de uma ação `remove` no nível do grupo (por exemplo, manter `tone` ao remover o grupo `identity`). As IDs de seção desconhecidas são processadas corretamente: o conteúdo das substituições de `replace`/`append`/`prepend` é acrescentado às instruções adicionais, e as substituições de `remove`são ignoradas silenciosamente.
Consulte os READMEs do SDK específicos do idioma para obter exemplos em [TypeScript](https://github.com/github/copilot-sdk/tree/main/nodejs/README.md), [Python](https://github.com/github/copilot-sdk/tree/main/python/README.md), [Go](https://github.com/github/copilot-sdk/tree/main/go/README.md), [Rust](https://github.com/github/copilot-sdk/tree/main/rust/README.md), [Java](https://github.com/github/copilot-sdk/tree/main/java/README.md) e [C#](https://github.com/github/copilot-sdk/tree/main/dotnet/README.md).
## Conectando-se a um servidor da CLI externa
Por padrão, o SDK gerencia automaticamente o ciclo de vida do processo da CLI Copilot, iniciando e interrompendo a CLI conforme necessário. No entanto, você também pode executar a CLI no modo de servidor separadamente e fazer com que o SDK se conecte a ela. Isso pode ser útil para:
* **Depuração**: mantenha a CLI em execução entre as reinicializações do SDK para inspecionar os logs
* **Compartilhamento de** recursos: vários clientes do SDK podem se conectar ao mesmo servidor da CLI
* **Desenvolvimento**: executar a CLI com configurações personalizadas ou em um ambiente diferente
### Executando a CLI no modo de servidor
Inicie a CLI no modo de servidor usando o `--headless` sinalizador e, opcionalmente, especifique uma porta:
```bash
copilot --headless --port 4321
```
Se você não especificar uma porta, a CLI escolherá uma porta disponível aleatória.
Por padrão, o servidor sem periféricos aceita apenas conexões de loopback (`127.0.0.1`), portanto o SDK deve ser executado na mesma máquina. Para aceitar conexões de outros hosts (por exemplo, ao executar a CLI em um contêiner ou em um servidor separado), associe a um endereço que não seja de loopback com `--host`:
```bash
# Listen on all interfaces
copilot --headless --host 0.0.0.0 --port 4321
```
> \[!WARNING]
> Expor o servidor sem periféricos em um endereço diferente de loopback faz com que ele fique acessível a qualquer pessoa que tenha uma rota até esse endereço. Emparelhe-o com controles de rede (firewall, rede privada, proxy reverso) e autenticação apropriada para seu ambiente.
### Conectando o SDK ao servidor externo
Depois que a CLI estiver em execução no modo de servidor, configure o cliente do SDK para se conectar a ele usando a opção "URL da CLI":
TypeScript
```typescript
import { CopilotClient, approveAll } from "@github/copilot-sdk";
const client = new CopilotClient({
cliUrl: "localhost:4321"
});
// Use the client normally
const session = await client.createSession({ onPermissionRequest: approveAll });
// ...
```
Python
```python
from copilot import CopilotClient, RuntimeConnection
from copilot.session import PermissionHandler
client = CopilotClient(connection=RuntimeConnection.for_uri("localhost:4321"))
await client.start()
# Use the client normally
session = await client.create_session(on_permission_request=PermissionHandler.approve_all)
# ...
```
Go
```golang
import copilot "github.com/github/copilot-sdk/go"
client := copilot.NewClient(&copilot.ClientOptions{
Connection: copilot.URIConnection{URL: "localhost:4321"},
})
if err := client.Start(ctx); err != nil {
log.Fatal(err)
}
defer client.Stop()
// Use the client normally
session, err := client.CreateSession(ctx, &copilot.SessionConfig{
OnPermissionRequest: copilot.PermissionHandler.ApproveAll,
})
// ...
```
Rust
```rust
use std::sync::Arc;
use github_copilot_sdk::handler::ApproveAllHandler;
use github_copilot_sdk::{Client, ClientOptions, SessionConfig, Transport};
let mut options = ClientOptions::default();
options.transport = Transport::External {
host: "localhost".to_string(),
port: 4321,
connection_token: None,
};
let client = Client::start(options).await?;
// Use the client normally
let session = client
.create_session(SessionConfig::default().with_permission_handler(Arc::new(ApproveAllHandler)))
.await?;
// ...
```
.NET
```csharp
using GitHub.Copilot;
using var client = new CopilotClient(new CopilotClientOptions
{
Connection = RuntimeConnection.ForUri("localhost:4321"),
});
// Use the client normally
await using var session = await client.CreateSessionAsync(new()
{
OnPermissionRequest = PermissionHandler.ApproveAll
});
// ...
```
Java
```java
import com.github.copilot.CopilotClient;
import com.github.copilot.rpc.*;
var client = new CopilotClient(
new CopilotClientOptions().setCliUrl("localhost:4321")
);
client.start().get();
// Use the client normally
var session = client.createSession(
new SessionConfig().setOnPermissionRequest(PermissionHandler.APPROVE_ALL)
).get();
// ...
```
**Nota:** Quando `cli_url` / `cliUrl` /Go's `URIConnection` é fornecido ou o Rust usa `Transport::External`, o SDK não gerará ou gerenciará um processo da CLI - ele só se conectará ao servidor existente na URL especificada.
## Telemetria e observabilidade
O SDK do Copilot dá suporte a [OpenTelemetry](https://opentelemetry.io/) para rastreamento distribuído. Forneça ao cliente uma configuração `telemetry` para permitir a exportação de rastreamentos do processo da CLI e a propagação automática de [W3C Trace Context](https://www.w3.org/TR/trace-context/) entre o SDK e a CLI.
### Habilitando a telemetria
Passe uma configuração `telemetry` (ou `Telemetry`) ao criar o cliente. Essa é a aceitação— nenhum sinalizador "habilitado" separado é necessário.
TypeScript
```typescript
import { CopilotClient } from "@github/copilot-sdk";
const client = new CopilotClient({
telemetry: {
otlpEndpoint: "http://localhost:4318",
},
});
```
Dependência de par opcional: `@opentelemetry/api`
Python
```python
from copilot import CopilotClient, CopilotClientOptions
client = CopilotClient(CopilotClientOptions(
telemetry={
"otlp_endpoint": "http://localhost:4318",
},
))
```
Instalar com extras de telemetria: `pip install copilot-sdk[telemetry]` (fornece `opentelemetry-api`)
Go
```golang
client := copilot.NewClient(&copilot.ClientOptions{
Telemetry: &copilot.TelemetryConfig{
OTLPEndpoint: "http://localhost:4318",
},
})
```
Dependência: `go.opentelemetry.io/otel`
Rust
```rust
use github_copilot_sdk::{Client, ClientOptions, OtelExporterType, TelemetryConfig};
let mut options = ClientOptions::default();
options.telemetry = Some(
TelemetryConfig::new()
.with_exporter_type(OtelExporterType::OtlpHttp)
.with_otlp_endpoint("http://localhost:4318"),
);
let client = Client::start(options).await?;
```
Nenhuma dependência extra — o SDK injeta variáveis de ambiente de telemetria para o processo de CLI gerado.
.NET
```csharp
var client = new CopilotClient(new CopilotClientOptions
{
Telemetry = new TelemetryConfig
{
OtlpEndpoint = "http://localhost:4318",
},
});
```
Nenhuma dependência extra — usa o recurso integrado `System.Diagnostics.Activity`.
Java
```java
import com.github.copilot.CopilotClient;
import com.github.copilot.rpc.*;
var client = new CopilotClient(new CopilotClientOptions()
.setTelemetry(new TelemetryConfig()
.setOtlpEndpoint("http://localhost:4318")));
```
Dependência: `io.opentelemetry:opentelemetry-api`
### Opções de TelemetryConfig
| Opção | Node.js | Python | Go | Rust | Java | .NET | Description |
| ------------------------- | ---------------- | ----------------- | ---------------- | ----------------- | ---------------- | ---------------- | ---------------------------------------------------------------------------- |
| Ponto de extremidade OTLP | `otlpEndpoint` | `otlp_endpoint` | `OTLPEndpoint` | `otlp_endpoint` | `otlpEndpoint` | `OtlpEndpoint` | URL do ponto de extremidade OTLP HTTP |
| Protocolo OTLP | `otlpProtocol` | `otlp_protocol` | `OTLPProtocol` | `otlp_protocol` | `otlpProtocol` | `OtlpProtocol` | Protocolo HTTP OTLP para todos os sinais: `"http/json"` ou `"http/protobuf"` |
| Caminho do arquivo | `filePath` | `file_path` | `FilePath` | `file_path` | `filePath` | `FilePath` | Caminho do arquivo para saída de rastreamento de linhas JSON |
| Tipo de exportador | `exporterType` | `exporter_type` | `ExporterType` | `exporter_type` | `exporterType` | `ExporterType` | |
| `"otlp-http"` ou `"file"` | | | | | | | |
| Nome de origem | `sourceName` | `source_name` | `SourceName` | `source_name` | `sourceName` | `SourceName` | Nome do escopo da instrumentação |
| Capturar conteúdo | `captureContent` | `capture_content` | `CaptureContent` | `capture_content` | `captureContent` | `CaptureContent` | Se o conteúdo da mensagem deve ser capturado |
O campo de protocolo OTLP configura o exportador `"otlp-http"` da CLI para todos os sinais. Deixe-o não definido para usar o padrão da CLI ou defina-o como `"http/protobuf"` para exportar protobuf por HTTP.
### Exportação de arquivo
Para gravar rastros em um arquivo local em vez de um endpoint OTLP:
```typescript
const client = new CopilotClient({
telemetry: {
filePath: "./traces.jsonl",
exporterType: "file",
},
});
```
### Propagação de contexto de traceamento
O contexto de rastreamento é propagado automaticamente— nenhuma instrumentação manual é necessária:
* **SDK → CLI**: os cabeçalhos `traceparent` e `tracestate` do span/atividade atuais são incluídos nas chamadas RPC `session.create`, `session.resume` e `session.send`.
* **CLI → SDK**: quando a CLI invoca manipuladores de ferramentas, o contexto de rastreamento do span da CLI é propagado para que o código da ferramenta seja executado sob o span pai correto.
📖
\*\*
[Instrumentação OpenTelemetry para o Copilot SDK](/pt/enterprise-cloud@latest/copilot/how-tos/copilot-sdk/observability/opentelemetry)\*\* — opções de TelemetryConfig, propagação de contexto de rastreamento e dependências por idioma.
## Saiba mais
* [Autenticação](/pt/enterprise-cloud@latest/copilot/how-tos/copilot-sdk/auth/authenticate) - GitHub OAuth, variáveis de ambiente e BYOK
* [BYOK (Bring Your Own Key - traga sua própria chave)](/pt/enterprise-cloud@latest/copilot/how-tos/copilot-sdk/auth/byok) - Use suas próprias chaves de API de Microsoft Foundry, OpenAI etc.
* [ Referência do SDK doNode.js](https://github.com/github/copilot-sdk/tree/main/nodejs/README.md)
* referência do SDK [Python](https://github.com/github/copilot-sdk/tree/main/python/README.md)
* [Referência do SDK do Go](https://github.com/github/copilot-sdk/tree/main/go/README.md)
* [Referência do SDK do Rust](https://github.com/github/copilot-sdk/tree/main/rust/README.md)
* [Referência do SDK .NET](https://github.com/github/copilot-sdk/tree/main/dotnet/README.md)
* referência do SDK [Java](https://github.com/github/copilot-sdk/tree/main/java/README.md)
* [Usando servidores MCP com o SDK do GitHub Copilot](/pt/enterprise-cloud@latest/copilot/how-tos/copilot-sdk/features/mcp) – Integrar ferramentas externas por meio do Protocolo de Contexto de Modelo
* [Documentação do servidor MCP do GitHub](https://github.com/github/github-mcp-server)
* [Diretório de servidores MCP](https://github.com/modelcontextprotocol/servers) – Explorar mais servidores MCP
* [Instrumentação OpenTelemetry para o Copilot SDK](/pt/enterprise-cloud@latest/copilot/how-tos/copilot-sdk/observability/opentelemetry) - TelemetryConfig, propagação do contexto de rastreamento e dependências por idioma
**Você fez isso!** Você aprendeu os principais conceitos do SDK do GitHub Copilot:
* ✅ Criando um cliente e uma sessão
* ✅ Enviar mensagens e receber respostas
* ✅ Streaming para saída em tempo real
* ✅ Definindo ferramentas personalizadas que o Copilot pode invocar
Agora vá criar algo incrível!
🚀