Créer un agent IA et ses outils

Article
10/30/2024

Important

Cette fonctionnalité est disponible en préversion publique.

Cet article explique comment créer et journaliser des agents IA et des outils à l’aide de Mosaic AI Agent Framework.

Découvrez comment utiliser AI Playground pour prototyper rapidement des agents appelant des outils et les exporter vers Mosaic AI Agent Framework.

Spécifications

Comprendre les concepts des agents et des outils d’IA, tels que décrits dans Qu’est-ce que le système IA composé et les agents IA ?
Databricks recommande d’installer la dernière version du client MLflow Python lors du développement d’agents. Pour des d’informations sur les exigences de version de mlflow, consultez Authentification pour les ressources dépendantes.

Créer des outils d’agent IA

Les agents IA utilisent des outils pour effectuer des actions en plus de la génération de langage, par exemple pour récupérer des données structurées ou non structurées, exécuter du code ou communiquer avec des services distants (par ex. l’envoi d’un e-mail ou d’un message Slack).

Pour fournir des outils à un agent avec Mosaic AI Agent Framework, vous pouvez utiliser n’importe quelle combinaison des méthodes suivantes :

Créez ou utilisez des fonctions de catalogue Unity existantes en tant qu’outils. Les fonctions catalogue Unity offrent une découverte, une gouvernance et un partage faciles, et fonctionnent bien pour l’application de transformations et d’agrégations sur des jeux de données volumineux.
Définir des outils localement en tant que fonctions Python dans le code de l’agent. Cette approche est utile dans les situations où vous devez effectuer des appels aux API REST, utiliser du code ou des bibliothèques arbitraires, ou exécuter des outils avec une latence très faible. Cette approche ne dispose pas de la détectabilité et de la gouvernance intégrées fournies par les fonctions de catalogue Unity. Databricks recommande de peser ce compromis lors de la création de votre agent pour déterminer quelle approche est la meilleure.

Les deux approches fonctionnent pour les agents écrits dans du code Python personnalisé ou à l’aide d’une bibliothèque de création d’agents comme LangGraph.

Lors de la définition d’outils, assurez-vous que l’outil, ses paramètres et sa valeur de retour sont documentés, afin que l’agent LLM puisse comprendre quand et comment utiliser l’outil.

Créer des outils d’agent avec des fonctions Unity Catalog

Ces exemples créent des outils d’agent IA à l’aide des fonctions Unity Catalog écrites dans un environnement de notebook ou dans un éditeur SQL.

Exécutez le code suivant dans une cellule notebook. Il utilise la commande magique %sql de notebook pour créer une fonction Unity Catalog appelée python_exec.

Un LLM peut utiliser cet outil pour exécuter du code Python fourni par un utilisateur.

%sql
CREATE OR REPLACE FUNCTION
main.default.python_exec (
 code STRING COMMENT 'Python code to execute. Remember to print the final result to stdout.'
)
RETURNS STRING
LANGUAGE PYTHON
DETERMINISTIC
COMMENT 'Executes Python code in the sandboxed environment and returns its stdout. The runtime is stateless and you can not read output of the previous tool executions. i.e. No such variables "rows", "observation" defined. Calling another tool inside a Python code is NOT allowed. Use standard python libraries only.'
AS $$
 import sys
 from io import StringIO
 sys_stdout = sys.stdout
 redirected_output = StringIO()
 sys.stdout = redirected_output
 exec(code)
 sys.stdout = sys_stdout
 return redirected_output.getvalue()
$$

Exécutez le code suivant dans un éditeur SQL.

Il crée une fonction Unity Catalog appelée lookup_customer_info, qu’un LLM peut utiliser pour récupérer des données structurées à partir d’une table hypothétique customer_data :

CREATE OR REPLACE FUNCTION main.default.lookup_customer_info(
  customer_name STRING COMMENT 'Name of the customer whose info to look up'
)
RETURNS STRING
COMMENT 'Returns metadata about a particular customer given the customer name, including the customer email and ID. The
customer ID can be used for other queries.'
RETURN SELECT CONCAT(
    'Customer ID: ', customer_id, ', ',
    'Customer Email: ', customer_email
  )
  FROM main.default.customer_data
  WHERE customer_name = customer_name
  LIMIT 1;

Prototypage d’agents appelant des outils dans AI Playground

Après avoir créé les fonctions Unity Catalog, vous pouvez utiliser AI Playground pour leur donner un LLM et tester l’agent. AI Playground fournit un bac à sable pour prototyper des agents appelant des outils.

Une fois que vous êtes satisfait de l’agent IA, vous pouvez l’exporter pour le développer davantage en Python ou le déployer tel quel en tant que point de terminaison Model Serving.

Remarque

Unity Catalog et le calcul serverless, Mosaic AI Agent Framework, et soit les modèles de fondation avec paiement par jeton ou les modèles externes doivent être disponibles dans l’espace de travail actuel pour prototyper des agents dans AI Playground.

Pour prototyper un point de terminaison appelant des outils.

Dans Playground, sélectionnez un modèle avec l’étiquette Appel de fonction.
Sélectionnez Outils et spécifiez les noms de votre fonction Unity Catalog dans la liste déroulante :
Discutez pour tester la combinaison actuelle de LLM, d’outils et d’invite du système, et essayez des variantes.

Exportez et déployez des agents AI Playground

Après avoir ajouté des outils et testé l’agent, exportez l’agent Playground vers des notebooks Python :

Cliquez sur Exporter le code de l’agent pour générer des notebooks Python qui vous aident à développer et déployer l’agent IA.

Après avoir exporté le code de l’agent, vous pouvez constater que trois fichiers sont enregistrés dans votre espace de travail :
- agent notebook : contient du code Python définissant votre agent à l’aide de LangChain.
- driver notebook : contient du code Python pour journaliser, suivre, inscrire et déployer l’agent IA à l’aide de Mosaic AI Agent Framework.
- config.yml : contient des informations de configuration sur votre agent, y compris les définitions d’outils.
Ouvrez le bloc-notes agent pour voir le code LangChain définissant votre agent, utilisez ce notebook pour tester et itérer sur l’agent par programmation, par exemple définir plus d’outils ou ajuster les paramètres de l’agent.

Remarque

Le code exporté peut avoir un comportement différent de votre session de IA Playground. Databricks recommande d’exécuter les notebooks exportés pour itérer et déboguer davantage, évaluer la qualité de l’agent, puis déployer l’agent pour partager avec d’autres personnes.
Une fois que vous êtes satisfait des résultats de l’agent, vous pouvez exécuter le notebook driver pour journaliser et déployer votre agent sur un point de terminaison Model Serving.

Définir un agent dans le code

En plus de générer du code d’agent à partir d’AI Playground, vous pouvez également définir un agent dans le code vous-même, à l’aide de cadres tels que LangChain ou du code Python. Pour déployer un agent à l’aide d’Agent Framework, son entrée doit être conforme à l’un des formats d’entrée et de sortie pris en charge.

Utiliser des paramètres pour configurer l’agent

Dans Agent Framework, vous pouvez utiliser des paramètres pour contrôler la façon dont les agents sont exécutés. Cela vous permet d’itérer rapidement en modifiant les caractéristiques de votre agent sans modifier le code. Les paramètres sont des paires clé-valeur que vous définissez dans un dictionnaire Python ou un fichier .yaml.

Pour configurer le code, créez un ModelConfig, un ensemble de paramètres clé-valeur. ModelConfig est un dictionnaire Python ou un fichier .yaml. Par exemple, vous pouvez utiliser un dictionnaire pendant le développement, puis le convertir en fichier .yaml pour le déploiement de production et CI/CD. Pour plus d’informations sur ModelConfig, consultez la documentation MLflow.

Voici un exemple de ModelConfig.

llm_parameters:
  max_tokens: 500
  temperature: 0.01
model_serving_endpoint: databricks-dbrx-instruct
vector_search_index: ml.docs.databricks_docs_index
prompt_template: 'You are a hello world bot. Respond with a reply to the user''s
  question that indicates your prompt template came from a YAML file. Your response
  must use the word "YAML" somewhere. User''s question: {question}'
prompt_template_input_vars:
- question

Pour appeler la configuration à partir de votre code, utilisez l’une des options suivantes :

# Example for loading from a .yml file
config_file = "configs/hello_world_config.yml"
model_config = mlflow.models.ModelConfig(development_config=config_file)

# Example of using a dictionary
config_dict = {
    "prompt_template": "You are a hello world bot. Respond with a reply to the user's question that is fun and interesting to the user. User's question: {question}",
    "prompt_template_input_vars": ["question"],
    "model_serving_endpoint": "databricks-dbrx-instruct",
    "llm_parameters": {"temperature": 0.01, "max_tokens": 500},
}

model_config = mlflow.models.ModelConfig(development_config=config_dict)

# Use model_config.get() to retrieve a parameter value
value = model_config.get('sample_param')

Formats d’entrée pris en charge

Voici les formats d’entrée pris en charge pour votre agent.

(Recommandé) Requêtes utilisant le schéma d’achèvement de conversation OpenAI. Il doit avoir un tableau d’objets en tant que paramètre messages. Ce format est idéal pour les applications RAG.

question = {
    "messages": [
        {
            "role": "user",
            "content": "What is Retrieval-Augmented Generation?",
        },
        {
            "role": "assistant",
            "content": "RAG, or Retrieval Augmented Generation, is a generative AI design pattern that combines a large language model (LLM) with external knowledge retrieval. This approach allows for real-time data connection to generative AI applications, improving their accuracy and quality by providing context from your data to the LLM during inference. Databricks offers integrated tools that support various RAG scenarios, such as unstructured data, structured data, tools & function calling, and agents.",
        },
        {
            "role": "user",
            "content": "How to build RAG for unstructured data",
        },
    ]
}

SplitChatMessagesRequest. Recommandé pour les applications de conversation multitours, en particulier lorsque vous souhaitez gérer séparément la requête actuelle et l’historique.

question = {
    "query": "What is MLflow",
    "history": [
        {
            "role": "user",
            "content": "What is Retrieval-augmented Generation?"
        },
        {
            "role": "assistant",
            "content": "RAG is"
        }
    ]
}

Pour LangChain, Databricks vous recommande d’écrire votre chaîne en langage LCEL (LangChain Expression Language). Dans votre code de définition de chaîne, vous pouvez utiliser un itemgetter pour obtenir les messages ou des objets query ou history en fonction du format d’entrée que vous utilisez.

Formats de sortie pris en charge

Votre agent doit avoir l’un des formats de sortie pris en charge suivants :

(Recommandé) ChatCompletionResponse. Ce format est recommandé pour les clients disposant de l’interopérabilité du format de réponse OpenAI.
StringObjectResponse. Ce format est le plus simple à interpréter.

Pour LangChain, utilisez StringResponseOutputParser() ou ChatCompletionsOutputParser() à partir de MLflow comme étape de chaîne finale. Cela met en forme le message IA LangChain dans un format d’agent(e) compatible.


  from mlflow.langchain.output_parsers import StringResponseOutputParser, ChatCompletionsOutputParser

  chain = (
      {
          "user_query": itemgetter("messages")
          | RunnableLambda(extract_user_query_string),
          "chat_history": itemgetter("messages") | RunnableLambda(extract_chat_history),
      }
      | RunnableLambda(fake_model)
      | StringResponseOutputParser() # use this for StringObjectResponse
      # ChatCompletionsOutputParser() # or use this for ChatCompletionResponse
  )

Si vous utilisez PyFunc, Databricks recommande d’utiliser des indicateurs de type pour annoter la fonction predict() avec des classes de données d’entrée et de sortie qui sont des sous-classes de classes définies dans mlflow.models.rag_signatures.

Vous pouvez construire un objet de sortie à partir de la classe de données à l’intérieur de predict() afin de vous assurer que le format est suivi. L’objet retourné doit être transformé en représentation de dictionnaire afin de garantir qu’il puisse être sérialisé.


  from mlflow.models.rag_signatures import ChatCompletionRequest, ChatCompletionResponse, ChainCompletionChoice, Message

  class RAGModel(PythonModel):
    ...
      def predict(self, context, model_input: ChatCompletionRequest) -> ChatCompletionResponse:
        ...
        return asdict(ChatCompletionResponse(
            choices=[ChainCompletionChoice(message=Message(content=text))]
        ))

Exemples de notebooks

Ces notebooks créent une chaîne simple « Hello, world » pour illustrer comment créer une application de chaîne dans Databricks. Le premier exemple crée une chaîne simple. Le deuxième exemple de notebook montre comment utiliser des paramètres pour réduire les modifications de code pendant le développement.

Partager via

Créer un agent IA et ses outils

Spécifications

Créer des outils d’agent IA

Créer des outils d’agent avec des fonctions Unity Catalog

Prototypage d’agents appelant des outils dans AI Playground

Exportez et déployez des agents AI Playground

Définir un agent dans le code

Utiliser des paramètres pour configurer l’agent

Formats d’entrée pris en charge

Formats de sortie pris en charge

Exemples de notebooks

Notebook de chaîne simple

Notebook pilote de chaîne simple

Notebook de chaîne paramétrisé

Notebook pilote de chaîne paramétrisé

Étapes suivantes

Commentaires

Ressources supplémentaires