> ## Documentation Index
> Fetch the complete documentation index at: /docs/llms.txt
> Use this file to discover all available pages before exploring further.

# Integração com o AWS Bedrock AgentCore

> Conecte o AI Gateway do Toqan Router ou invoque agentes do Toqan Router a partir do AWS Bedrock AgentCore Runtime, com fallbacks, rastreamento de custos e tracing via OpenTelemetry.

O **AWS Bedrock AgentCore Runtime** é um ambiente de hospedagem serverless para implantar agentes criados com qualquer framework (Strands, LangGraph, CrewAI) em escala de produção, sem gerenciar infraestrutura. Conecte o **AI Gateway** de dentro do AgentCore para acessar mais de 500 modelos de mais de 30 provedores, com fallbacks automáticos, rastreamento de custos e observabilidade completa.

> [card] [AI Gateway](#ai-gateway)
>
> Roteie chamadas de LLM pelo **AI Gateway** dentro do AgentCore alterando apenas a URL base.

> [card] [Agents do Toqan Router](#toqan-router-agents)
>
> Invoque qualquer Agent do **Toqan Router** pela chave, de dentro do AgentCore, usando a OpenAI Responses API.

## AI Gateway

Conecte o **AI Gateway** a um entrypoint do AgentCore para acessar mais de 500 LLMs de mais de 30 provedores, com fallbacks automáticos, rastreamento de custos e observabilidade.

### OpenAI Agents SDK

**Instalação:**

```bash Bash theme={"theme":{"light":"github-light","dark":"github-dark"}}
pip install openai-agents openai bedrock-agentcore
```

Configure um cliente `AsyncOpenAI` com a URL base do **AI Gateway** e depois envolva o agente em um entrypoint `BedrockAgentCoreApp`:

```python Python theme={"theme":{"light":"github-light","dark":"github-dark"}}
import os
from openai import AsyncOpenAI
from agents import Agent, Runner, set_default_openai_client, set_tracing_disabled
from bedrock_agentcore.runtime import BedrockAgentCoreApp

client = AsyncOpenAI(
    api_key=os.getenv("TOQAN_API_KEY"),
    base_url="https://router.toqan.ai/eu/v3/router"
)
set_tracing_disabled(True)
set_default_openai_client(client)

agent = Agent(
    name="Assistant",
    instructions="You are a helpful assistant.",
    model="openai/gpt-5.6-sol"
)

app = BedrockAgentCoreApp()

@app.entrypoint
async def agent_invocation(payload, context):
    query = payload.get("prompt", "How can I help you?")
    result = await Runner.run(agent, query)
    return {"result": result.final_output}

app.run()
```

### Strands Agents

**Instalação:**

```bash Bash theme={"theme":{"light":"github-light","dark":"github-dark"}}
pip install strands-agents bedrock-agentcore
```

Use `OpenAIModel` com a URL base do **AI Gateway** dentro de um agente Strands:

```python Python theme={"theme":{"light":"github-light","dark":"github-dark"}}
import os
from strands import Agent
from strands.models.openai import OpenAIModel
from bedrock_agentcore.runtime import BedrockAgentCoreApp

model = OpenAIModel(
    model_id="openai/gpt-5.6-sol",
    client_args={
        "api_key": os.getenv("TOQAN_API_KEY"),
        "base_url": "https://router.toqan.ai/eu/v3/router"
    }
)

agent = Agent(
    model=model,
    system_prompt="You are a helpful assistant."
)

app = BedrockAgentCoreApp()

@app.entrypoint
def agent_invocation(payload, context):
    result = agent(payload.get("prompt", "How can I help?"))
    return {"result": str(result)}

app.run()
```

## Agents do Toqan Router

Invoque qualquer Agent do **Toqan Router** pela chave usando `model="agent/YOUR_AGENT_KEY"` com a OpenAI Responses API. O **AI Gateway** executa o agente configurado, incluindo seu system prompt, ferramentas, avaliadores e configurações de modelo.

> [!NOTE]
>
> Encontre a chave do agente na página Agents do **Toqan Router**.

```python Python theme={"theme":{"light":"github-light","dark":"github-dark"}}
import os
from openai import AsyncOpenAI
from bedrock_agentcore.runtime import BedrockAgentCoreApp

client = AsyncOpenAI(
    api_key=os.getenv("TOQAN_API_KEY"),
    base_url="https://router.toqan.ai/eu/v3/router"
)

app = BedrockAgentCoreApp()

@app.entrypoint
async def agent_invocation(payload, context):
    query = payload.get("prompt", "How can I help you?")
    response = await client.responses.create(
        model="agent/YOUR_AGENT_KEY",
        input=query
    )
    return {"result": response.output_text}

app.run()
```

## Observabilidade

Capture traces das execuções do AgentCore e envie-os ao **Toqan Router** usando OpenTelemetry.

### Instalação

```bash Bash theme={"theme":{"light":"github-light","dark":"github-dark"}}
pip install openai bedrock-agentcore opentelemetry-sdk opentelemetry-exporter-otlp-proto-http openinference-instrumentation-openai
```

### Configuração

Configure o exportador OTLP e instrumente o cliente OpenAI antes de iniciar o app:

```python Python theme={"theme":{"light":"github-light","dark":"github-dark"}}
import os
from opentelemetry.sdk.trace import TracerProvider
from opentelemetry.sdk.trace.export import BatchSpanProcessor
from opentelemetry.exporter.otlp.proto.http.trace_exporter import OTLPSpanExporter
from openinference.instrumentation.openai import OpenAIInstrumentor
from openai import AsyncOpenAI
from bedrock_agentcore.runtime import BedrockAgentCoreApp

exporter = OTLPSpanExporter(
    endpoint="https://router.toqan.ai/eu/v2/otel/v1/traces",
    headers={"Authorization": f"Bearer {os.getenv('TOQAN_API_KEY')}"}
)
provider = TracerProvider()
provider.add_span_processor(BatchSpanProcessor(exporter))
OpenAIInstrumentor().instrument(tracer_provider=provider)

client = AsyncOpenAI(
    api_key=os.getenv("OPENAI_API_KEY")
)

app = BedrockAgentCoreApp()

@app.entrypoint
async def agent_invocation(payload, context):
    query = payload.get("prompt", "How can I help you?")
    response = await client.responses.create(
        model="gpt-5.6-sol",
        input=query
    )
    return {"result": response.output_text}

app.run()
```

Veja os traces no [AI Studio](https://router.toqan.ai/eu), na aba **Traces**.


This documentation is built and hosted on [Mintlify](https://mintlify.com), a developer documentation platform.