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

# Cómo generar un Word desde Amazon Bedrock con la API Converse

> Pasa doconda.tools() como toolConfig a converse: el modelo llama a create_document y recibes el enlace al .docx y a su PDF.

Instala `doconda` (o `@doconda/sdk`) y pasa `doconda.tools()` como `toolConfig` a la API Converse de Bedrock. Cuando el
modelo pide la herramienta `create_document`, la ejecutas con `run()` y recibes el Word (`.docx`) y su PDF con sus
enlaces de descarga.

## Pasos

1. Activa un modelo en tu cuenta de Bedrock y guarda su id en `BEDROCK_MODEL_ID`. Las credenciales de AWS salen de tu
   entorno (`AWS_REGION`, `AWS_ACCESS_KEY_ID`…).
2. Crea una API key de Doconda en el panel, en **API keys**, y guárdala en `DOCONDA_API_KEY`.
3. Instala las dependencias y ejecuta el bucle de Converse: mientras `stopReason` sea `tool_use`, ejecutas la
   herramienta y le devuelves el resultado al modelo.

<CodeGroup>
  ```python Python theme={"theme":{"light":"github-light","dark":"github-dark-dimmed"}}
  # pip install boto3 doconda
  import json
  import os

  import boto3
  from doconda import Doconda

  bedrock = boto3.client("bedrock-runtime")
  tools = Doconda().tools()
  tool_config = {"tools": [{"toolSpec": {"name": t.name, "description": t.description, "inputSchema": {"json": t.input_schema}}} for t in tools]}
  messages = [{"role": "user", "content": [{"text": "Redacta en Word un informe sobre el teletrabajo en la empresa"}]}]

  while True:
      res = bedrock.converse(modelId=os.environ["BEDROCK_MODEL_ID"], messages=messages, toolConfig=tool_config)
      message = res["output"]["message"]
      messages.append(message)
      if res["stopReason"] != "tool_use":
          break
      results = []
      for block in message["content"]:
          if "toolUse" in block:
              use = block["toolUse"]
              out = next(t for t in tools if t.name == use["name"]).run(use["input"])
              results.append({"toolResult": {"toolUseId": use["toolUseId"], "content": [{"text": json.dumps(out)}]}})
      messages.append({"role": "user", "content": results})

  print("".join(block.get("text", "") for block in message["content"]))
  ```

  ```ts TypeScript theme={"theme":{"light":"github-light","dark":"github-dark-dimmed"}}
  // npm install @aws-sdk/client-bedrock-runtime @doconda/sdk
  import { BedrockRuntimeClient, ConverseCommand, type Message } from "@aws-sdk/client-bedrock-runtime"
  import { Doconda } from "@doconda/sdk"

  const bedrock = new BedrockRuntimeClient({})
  const tools = new Doconda().tools()
  const toolConfig = { tools: tools.map((t) => ({ toolSpec: { name: t.name, description: t.description, inputSchema: { json: t.inputSchema } } })) }
  const messages: Message[] = [{ role: "user", content: [{ text: "Redacta en Word un informe sobre el teletrabajo en la empresa" }] }]

  while (true) {
    const res = await bedrock.send(new ConverseCommand({ modelId: process.env.BEDROCK_MODEL_ID, messages, toolConfig }))
    const message = res.output?.message
    if (!message) break
    messages.push(message)
    if (res.stopReason !== "tool_use") break
    const content = await Promise.all(
      message.content!.filter((b) => b.toolUse).map(async ({ toolUse }) => {
        const result = await tools.find((t) => t.name === toolUse!.name)!.run(toolUse!.input as Record<string, unknown>)
        return { toolResult: { toolUseId: toolUse!.toolUseId, content: [{ text: JSON.stringify(result) }] } }
      }),
    )
    messages.push({ role: "user", content })
  }
  ```
</CodeGroup>

El mismo bucle sirve para un agente propio montado sobre Bedrock: el agente decide cuándo crear el documento y tú solo
ejecutas la herramienta.

## Qué devuelve

La herramienta devuelve al modelo un resumen corto, que el modelo pasa al usuario:

```json theme={"theme":{"light":"github-light","dark":"github-dark-dimmed"}}
{
  "id": "doc_01JAB3…",
  "format": "docx",
  "status": "ready",
  "links": { "docx": "https://…", "pdf": "https://…" },
  "links_note": "Links expire in 5 minutes: call get_document for fresh ones."
}
```

* `status`: `ready`, `ready_with_warnings`, `needs_review` (hay algo que mirar en el informe) o `failed` (no se cobra).
* `links`: el Word editable y su PDF. Caducan a los 5 minutos; el agente pide otros con `get_document`.

## Preguntas frecuentes

<AccordionGroup>
  <Accordion title="¿Funciona con cualquier modelo de Bedrock?">
    Con cualquier modelo activado en tu cuenta que admita herramientas en la API Converse. Las herramientas son JSON
    Schema estándar.
  </Accordion>

  <Accordion title="¿Puedo pedir un PowerPoint o un Excel con el mismo código?">
    Sí. `create_document` también crea PDF, PowerPoint y Excel; el modelo elige `format` según lo que pida el usuario.
  </Accordion>

  <Accordion title="¿Cuánto cuesta?">
    Pagas por documento entregado; los que fallan no se cobran. Lo que hace el agente cuesta lo mismo que con la API.
    Ver [precios](/guides/account#precios).
  </Accordion>

  <Accordion title="¿Dónde se guardan los documentos?">
    En la Unión Europea (Irlanda), y la IA que los procesa también funciona en la UE.
  </Accordion>
</AccordionGroup>

## Sigue leyendo

* [Amazon Bedrock](/agents/bedrock): la guía completa, también con el AI SDK.
* [Quickstart](/quickstart): tu primer documento con la API.


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