Elección de herramientas con modelos Amazon Nova

En muchas aplicaciones generativas de IA, un modelo de lenguaje grande (LLM) como Amazon Nova se utiliza para responder a una consulta de usuario basada en el conocimiento o el contexto del modelo que se proporciona. Sin embargo, a medida que los casos de uso han madurado, la capacidad de un modelo de tener acceso a herramientas o estructuras que estarían inherentemente fuera del marco de referencia del modelo se ha vuelto primordial. Esto podría ser API, funciones de código o esquemas y estructuras requeridas por su aplicación final. Esta capacidad se ha convertido en lo que se conoce como Uso de la herramienta o Funciones llamadas.

Para agregar un control de grano fino a cómo se utilizan las herramientas, hemos lanzado una función para la elección de herramientas para los modelos Amazon Nova. En lugar de confiar en la ingeniería rápida, la elección de la herramienta obliga al modelo a adherirse a la configuración en su lugar.

En esta publicación, discutimos el uso de herramientas y la nueva función de elección de herramientas, con casos de uso de ejemplo.

Uso de la herramienta con Amazon Nova

Para ilustrar el concepto de uso de herramientas, podemos imaginar una situación en la que proporcionemos acceso de Amazon Nova a algunas herramientas diferentes, como una calculadora o una API meteorológica. Según la consulta del usuario, Amazon Nova seleccionará la herramienta apropiada y le dirá cómo usarla. Por ejemplo, si un usuario pregunta “¿Cuál es el clima en Seattle?” Amazon Nova usará la herramienta meteorológica.

El siguiente diagrama ilustra un flujo de trabajo de ejemplo entre un modelo de Amazon Nova, sus herramientas disponibles y recursos externos relacionados.

El uso de la herramienta en el núcleo es la selección de la herramienta y sus parámetros. La responsabilidad de ejecutar la funcionalidad externa se deja a la aplicación o al desarrollador. Después de que la aplicación ejecuta la herramienta, puede devolver los resultados al modelo para la generación de la respuesta final.

Exploremos algunos ejemplos con más detalle. El siguiente diagrama ilustra el flujo de trabajo de un modelo de Amazon Nova utilizando una llamada de función para acceder a una API meteorológica y devolver la respuesta al usuario.

El siguiente diagrama ilustra el flujo de trabajo de un modelo de Amazon Nova utilizando una llamada de función para acceder a una herramienta de calculadora.

Elección de herramientas con Amazon Nova

El toolChoice El parámetro API le permite controlar cuando se llama a una herramienta. Hay tres opciones compatibles para este parámetro:

Cualquier – con la elección de herramientas Anyel modelo seleccionará al menos una de las herramientas disponibles cada vez:
```
{
   "toolChoice": {
        "any": {}
    }
}
```
Herramienta – con la elección de herramientas Toolel modelo siempre usará la herramienta solicitada:
```
{
   "toolChoice": {
        "tool": {
            "name": "name_of_tool"
        }
    }
}
```
Auto – Elección de herramientas Auto es el comportamiento predeterminado y dejará la selección de la herramienta por completo hasta el modelo:
```
{
   "toolChoice": {
        "auto": {}
    }
}
```

Una táctica popular para mejorar las capacidades de razonamiento de un modelo es usar la cadena de pensamiento. Al usar la elección de la herramienta de autoAmazon Nova usará la cadena de pensamiento y la respuesta del modelo incluirá tanto el razonamiento como la herramienta que se seleccionó.

Este comportamiento diferirá según el caso de uso. Cuando tool o any se seleccionan como la elección de la herramienta, Amazon Nova generará solo las herramientas y no la cadena de pensamiento de salida.

Casos de uso

En esta sección, exploramos diferentes casos de uso para la elección de herramientas.

Salida estructurada/modo JSON

En ciertos escenarios, es posible que desee Amazon Nova use una herramienta específica para responder a la pregunta del usuario, incluso si Amazon Nova cree que puede proporcionar una respuesta sin el uso de una herramienta. Un caso de uso común para este enfoque es hacer cumplir la salida estructurada/modo JSON. A menudo es fundamental tener la salida estructurada de retorno de LLMS, porque esto permite que los casos de uso aguas abajo consuman y procesen de manera más efectiva las salidas generadas. En estos casos, las herramientas empleadas no necesariamente necesitan ser funciones del lado del cliente: se pueden usar cuando se requiere que el modelo devuelva la salida JSON que se adhiera a un esquema predefinido, lo que obliga a Amazon Nova a usar la herramienta especificada.

Al usar herramientas para hacer cumplir la salida estructurada, proporciona una herramienta única con un JSON descriptivo inputSchema. Especifica la herramienta con {"tool" : {"name" : "Your tool name"}}. El modelo pasará la entrada a la herramienta, por lo que el nombre de la herramienta y su descripción deben ser desde la perspectiva del modelo.

Por ejemplo, considere un sitio web de alimentos. Cuando se le proporciona una descripción del plato, el sitio web puede extraer los detalles de la receta, como el tiempo de cocción, los ingredientes, el nombre del plato y el nivel de dificultad, para facilitar las capacidades de búsqueda y filtrado de usuarios. Vea el siguiente código de ejemplo:

import boto3
import json

tool_config = {
    "toolChoice": {
        "name": { "tool" : "extract_recipe"}
    },
    "tools": [
        {
            "toolSpec": {
                "name": "extract_recipe",
                "description": "Extract recipe for cooking instructions",
                "inputSchema": {
                    "json": {
                        "type": "object",
                        "properties": {
                            "recipe": {
                                "type": "object",
                                "properties": {
                                    "name": {
                                        "type": "string",
                                        "description": "Name of the recipe"
                                    },
                                    "description": {
                                        "type": "string",
                                        "description": "Brief description of the dish"
                                    },
                                    "prep_time": {
                                        "type": "integer",
                                        "description": "Preparation time in minutes"
                                    },
                                    "cook_time": {
                                        "type": "integer",
                                        "description": "Cooking time in minutes"
                                    },
                                    "servings": {
                                        "type": "integer",
                                        "description": "Number of servings"
                                    },
                                    "difficulty": {
                                        "type": "string",
                                        "enum": ["easy", "medium", "hard"],
                                        "description": "Difficulty level of the recipe"
                                    },
                                    "ingredients": {
                                        "type": "array",
                                        "items": {
                                            "type": "object",
                                            "properties": {
                                                "item": {
                                                    "type": "string",
                                                    "description": "Name of ingredient"
                                                },
                                                "amount": {
                                                    "type": "number",
                                                    "description": "Quantity of ingredient"
                                                },
                                                "unit": {
                                                    "type": "string",
                                                    "description": "Unit of measurement"
                                                }
                                            },
                                            "required": ["item", "amount", "unit"]
                                        }
                                    },
                                    "instructions": {
                                        "type": "array",
                                        "items": {
                                            "type": "string",
                                            "description": "Step-by-step cooking instructions"
                                        }
                                    },
                                    "tags": {
                                        "type": "array",
                                        "items": {
                                            "type": "string",
                                            "description": "Categories or labels for the recipe"
                                        }
                                    }
                                },
                                "required": ["name", "ingredients", "instructions"]
                            }
                        },
                        "required": ["recipe"]
                    }
                }
            }
        }
    ]
}

messages = [{
    "role": "user",
    "content": [
        {"text": input_text},
    ]
}]

inf_params = {"topP": 1, "temperature": 1}

client = boto3.client("bedrock-runtime", region_name="us-east-1")

response = client.converse(
    modelId="us.amazon.nova-micro-v1:0",
    messages=messages,
    toolConfig=tool_config,
    inferenceConfig=inf_params,
    additionalModelRequestFields= {"inferenceConfig": { "topK": 1 } }
)
print(json.dumps(response['output']['message']['content'][0][], indent=2))

Podemos proporcionar una descripción detallada de un plato como entrada de texto:

Legend has it that this decadent chocolate lava cake was born out of a baking mistake in New York's Any Kitchen back in 1987, when chef John Doe pulled a chocolate sponge cake out of the oven too early, only to discover that the dessert world would never be the same. Today I'm sharing my foolproof version, refined over countless dinner parties. Picture a delicate chocolate cake that, when pierced with a fork, releases a stream of warm, velvety chocolate sauce – it's pure theater at the table. While it looks like a restaurant-worthy masterpiece, the beauty lies in its simplicity: just six ingredients (good quality dark chocolate, unsalted butter, eggs, sugar, flour, and a pinch of salt) transform into individual cakes in under 15 minutes. The secret? Precise timing is everything. Pull them from the oven a minute too late, and you'll miss that magical molten center; too early, and they'll be raw. But hit that sweet spot at exactly 12 minutes, when the edges are set but the center still wobbles slightly, and you've achieved dessert perfection. I love serving these straight from the oven, dusted with powdered sugar and topped with a small scoop of vanilla bean ice cream that slowly melts into the warm cake. The contrast of temperatures and textures – warm and cold, crisp and gooey – makes this simple dessert absolutely unforgettable.

Podemos obligar a Amazon Nova a usar la herramienta extract_recipeque generará una salida JSON estructurada que se adhiere al esquema predefinido proporcionado como el esquema de entrada de la herramienta:

 {
  "toolUseId": "tooluse_4YT_DYwGQlicsNYMbWFGPA",
  "name": "extract_recipe",
  "input": {
    "recipe": {
      "name": "Decadent Chocolate Lava Cake",
      "description": "A delicate chocolate cake that releases a stream of warm, velvety chocolate sauce when pierced with a fork. It's pure theater at the table.",
      "difficulty": "medium",
      "ingredients": [
        {
          "item": "good quality dark chocolate",
          "amount": 125,
          "unit": "g"
        },
        {
          "item": "unsalted butter",
          "amount": 125,
          "unit": "g"
        },
        {
          "item": "eggs",
          "amount": 4,
          "unit": ""
        },
        {
          "item": "sugar",
          "amount": 100,
          "unit": "g"
        },
        {
          "item": "flour",
          "amount": 50,
          "unit": "g"
        },
        {
          "item": "salt",
          "amount": 0.5,
          "unit": "pinch"
        }
      ],
      "instructions": [
        "Preheat the oven to 200\u00b0C (400\u00b0F).",
        "Melt the chocolate and butter together in a heatproof bowl over a saucepan of simmering water.",
        "In a separate bowl, whisk the eggs and sugar until pale and creamy.",
        "Fold the melted chocolate mixture into the egg and sugar mixture.",
        "Sift the flour and salt into the mixture and gently fold until just combined.",
        "Divide the mixture among six ramekins and bake for 12 minutes.",
        "Serve straight from the oven, dusted with powdered sugar and topped with a small scoop of vanilla bean ice cream."
      ],
      "prep_time": 10,
      "cook_time": 12,
      "servings": 6,
      "tags": [
        "dessert",
        "chocolate",
        "cake"
      ]
    }
  }
}

Generación de API

Otro escenario común es exigir a Amazon Nova que seleccione una herramienta de las opciones disponibles sin importar el contexto de la consulta del usuario. Un ejemplo de esto es con la selección de punto final API. En esta situación, no conocemos la herramienta específica para usar, y permitimos que el modelo elija entre los disponibles.

Con la elección de la herramienta de anypuede asegurarse de que el modelo siempre use al menos una de las herramientas disponibles. Debido a esto, proporcionamos una herramienta que puede usarse para cuando una API no es relevante. Otro ejemplo sería proporcionar una herramienta que permita preguntas aclaratorias.

En este ejemplo, proporcionamos al modelo dos API diferentes y una herramienta API no compatible que seleccionará en función de la consulta de usuario:

import boto3
import json

tool_config = {
    "toolChoice": {
        "any": {}
    },
    "tools": [
         {
            "toolSpec": {
                "name": "get_all_products",
                "description": "API to retrieve multiple products with filtering and pagination options",
                "inputSchema": {
                    "json": {
                        "type": "object",
                        "properties": {
                            "sort_by": {
                                "type": "string",
                                "description": "Field to sort results by. One of: price, name, created_date, popularity",
                                "default": "created_date"
                            },
                            "sort_order": {
                                "type": "string",
                                "description": "Order of sorting (ascending or descending). One of: asc, desc",
                                "default": "desc"
                            },
                        },
                        "required": []
                    }
                }
            }
        },
        {
            "toolSpec": {
                "name": "get_products_by_id",
                "description": "API to retrieve retail products based on search criteria",
                "inputSchema": {
                    "json": {
                        "type": "object",
                        "properties": {
                            "product_id": {
                                "type": "string",
                                "description": "Unique identifier of the product"
                            },
                        },
                        "required": ["product_id"]
                    }
                }
            }
        },
        {
            "toolSpec": {
                "name": "unsupported_api",
                "description": "API to use when the user query does not relate to the other available APIs",
                "inputSchema": {
                    "json": {
                        "type": "object",
                        "properties": {
                            "reasoning": {
                                "type": "string",
                                "description": "The reasoning for why the user query did not have a valid API available"
                            },
                        },
                        "required": ["reasoning"]
                    }
                }
            }
        }
    ]
}


messages = [{
    "role": "user",
    "content": [
        {"text": input_text},
    ]
}]

inf_params = {"topP": 1, "temperature": 1}

client = boto3.client("bedrock-runtime", region_name="us-east-1")

response = client.converse(
    modelId="us.amazon.nova-micro-v1:0",
    messages=messages,
    toolConfig=tool_config,
    inferenceConfig=inf_params,
    additionalModelRequestFields= {"inferenceConfig": { "topK": 1 } }
)

print(json.dumps(response['output']['message']['content'][0], indent=2))

Una entrada del usuario de “¿Puede obtener todos los productos disponibles?” emitiría lo siguiente:

{
  "toolUse": {
    "toolUseId": "tooluse_YCNbT0GwSAyjIYOuWnDhkw",
    "name": "get_all_products",
    "input": {}
  }
}

Mientras que “¿Puedes obtener mis pedidos más recientes?” emitiría lo siguiente:

{
  "toolUse": {
    "toolUseId": "tooluse_jpiZnrVcQDS1sAa-qPwIQw",
    "name": "unsupported_api",
    "input": {
      "reasoning": "The available tools do not support retrieving user orders. The user's request is for personal order information, which is not covered by the provided APIs."
    }
  }
}

Chatear con la búsqueda

La opción final para la elección de la herramienta es auto. Este es el comportamiento predeterminado, por lo que es consistente con no proporcionar ninguna opción de herramienta en absoluto.

El uso de esta opción de herramienta permitirá la opción de uso de la herramienta o simplemente la salida de texto. Si el modelo selecciona una herramienta, habrá un bloque de herramientas y un bloque de texto. Si el modelo responde sin herramienta, solo se devuelve un bloque de texto. En el siguiente ejemplo, queremos permitir que el modelo responda al usuario o llame a una herramienta si es necesario:

import boto3
import json

tool_config = {
    "toolChoice": {
        "auto": {}
    },
    "tools": [
         {
            "toolSpec": {
                "name": "search",
                "description": "API that provides access to the internet",
                "inputSchema": {
                    "json": {
                        "type": "object",
                        "properties": {
                            "query": {
                                "type": "string",
                                "description": "Query to search by",
                            },
                        },
                        "required": ["query"]
                    }
                }
            }
        }
    ]
}

messages = [{
    "role": "user",
    "content": [
        {"text": input_text},
    ]
}]

system = [{
    "text": "ou are a helpful chatbot. You can use a tool if necessary or respond to the user query"
}]

inf_params = {"topP": 1, "temperature": 1}

client = boto3.client("bedrock-runtime", region_name="us-east-1")

response = client.converse(
    modelId="us.amazon.nova-micro-v1:0",
    messages=messages,
    toolConfig=tool_config,
    inferenceConfig=inf_params,
    additionalModelRequestFields= {"inferenceConfig": { "topK": 1 } }
)


if (response["stopReason"] == "tool_use"):
    tool_use = next(
        block["toolUse"]
        for block in response["output"]["message"]["content"]
            if "toolUse" in block
    )
   print(json.dumps(tool_use, indent=2))
 else:
    pattern = r'<thinking>.*?</thinking>\\n\\n|<thinking>.*?</thinking>'
    text_response = response["output"]["message"]["content"][0]["text"]
    stripped_text = re.sub(pattern, '', text_response, flags=re.DOTALL)
    
    print(stripped_text)

Una entrada del usuario de “¿Cuál es el clima en San Francisco?” resultaría en una llamada de herramienta:

{
  "toolUseId": "tooluse_IwtBnbuuSoynn1qFiGtmHA",
  "name": "search",
  "input": {
    "query": "what is the weather in san francisco"
  }
}

Mientras que le hace al modelo una pregunta directa como “¿Cuántos meses hay en un año?” respondería con una respuesta de texto al usuario:

There are 12 months in a year.

Consideraciones

Hay algunas mejores prácticas que se requieren para las llamadas de herramientas con modelos Nova. El primero es usar decodificación codiciosa parámetros. Con los modelos Amazon Nova, eso requiere establecer una temperatura, Top P y Top K de 1. Puede consultar los ejemplos de código anteriores sobre cómo establecerlos. El uso de parámetros de decodificación codiciosos obliga a los modelos a producir respuestas deterministas y mejora la tasa de éxito de la llamada de herramientas.

La segunda consideración es el esquema JSON que está utilizando para la consideración de la herramienta. Al momento de escribir este artículo, Amazon Nova Models admite un subconjunto limitado de esquemas JSON, por lo que es posible que el modelo no los recoja como se esperaba. Los campos comunes serían $def y $ref campos. Asegúrese de que su esquema tenga el siguiente conjunto de campos de nivel superior: type (Debe ser object), propertiesy required.

Por último, para el mayor impacto en el éxito de las llamadas de herramientas, debe optimizar las configuraciones de su herramienta. Las descripciones y los nombres deben ser muy claros. Si hay matices de cuándo se debe llamar a una herramienta sobre la otra, asegúrese de incluirlo concisamente en las descripciones de la herramienta.

Conclusión

El uso de la elección de herramientas en los flujos de trabajo de llamadas de herramientas es una forma escalable de controlar cómo un modelo invoca herramientas. En lugar de confiar en la ingeniería rápida, la elección de la herramienta obliga al modelo a adherirse a la configuración en su lugar. Sin embargo, hay complejidades para las llamadas de herramientas; Para obtener más información, consulte Uso de herramientas (llamadas de funciones) con Amazon Nova, Sistemas de llamadas de herramientasy Llamadas de la herramienta de solución de problemas.

Explorar como Modelos de Amazon Nova puede mejorar sus casos generativos de uso de IA hoy.

Sobre los autores

Granjero de jean es un arquitecto generativo de soluciones de IA en el equipo de Inteligencia General Artificial (AGI) de Amazon, especializada en aplicaciones de agente. Con sede en Seattle, Washington, trabaja en la intersección de sistemas de IA autónomos y soluciones comerciales prácticas, ayudando a dar forma al futuro de AGI en Amazon.

Sharon Li es un arquitecto de soluciones especializadas de IA/ML en Amazon Web Services (AWS) con sede en Boston, Massachusetts. Con una pasión por aprovechar la tecnología de vanguardia, Sharon está a la vanguardia de desarrollar e implementar soluciones innovadoras de IA generativas en la plataforma AWS Cloud.

Lulu Wong es un diseñador de AI UX en el equipo de inteligencia general artificial de Amazon (AGI). Con experiencia en informática, diseño de aprendizaje y experiencia del usuario, une los dominios técnicos y de experiencia del usuario al dar forma a cómo los sistemas de IA interactúan con los humanos, refinando los comportamientos de entrada-salida del modelo y la creación de recursos para hacer que los productos de IA sean más accesibles para los usuarios.

Elección de herramientas con modelos Amazon Nova

ByEquipo de 7 minutos

Uso de la herramienta con Amazon Nova

Elección de herramientas con Amazon Nova

Casos de uso

Salida estructurada/modo JSON

Generación de API

Chatear con la búsqueda

Consideraciones

Conclusión

Sobre los autores

By Equipo de 7 minutos

Related Post

Google DeepMind y A24 lanzan una asociación de investigación

Conozca el agente de página de Alibaba: un agente GUI de JavaScript en la página que controla las interfaces web con lenguaje natural a través del DOM

Conozca WebBrain: un agente de navegador de IA local y de código abierto que lee páginas y automatiza tareas en Chrome y Firefox

You missed

Vendedor de lotería vende cupón ganador de 500.000€ « Euro Weekly News

Google DeepMind y A24 lanzan una asociación de investigación

Una proteína cerebral común puede ayudar a propagar la enfermedad de Alzheimer, y comprender esto podría conducir a nuevos tratamientos

Jung Chang sobre Londres, el exilio, la memoria y la madre que hizo posible Wild Swans