Het invoer- en uitvoerschema van een agent definiëren

AI-agents moeten voldoen aan specifieke vereisten voor invoer- en uitvoerschema's om compatibel te zijn met andere functies in Azure Databricks. In dit artikel wordt uitgelegd hoe u ervoor kunt zorgen dat uw AI-agent aan deze vereisten voldoet en hoe u het invoer- en uitvoerschema van uw agent aanpast en tegelijkertijd compatibiliteit garandeert.

Mozaïek AI maakt gebruik van MLflow Model Signatures om de vereisten voor invoer- en uitvoerschema's van een agent te definiëren. De modelhandtekening vertelt interne en externe onderdelen hoe u met uw agent kunt communiceren en controleert of deze voldoen aan het schema.

OpenAI-voltooiingsschema voor chats (aanbevolen)

Databricks raadt aan het OpenAI-voltooiingsschema voor chats te gebruiken om agentinvoer en -uitvoer te definiëren. Dit schema wordt veel gebruikt en compatibel met veel agentframeworks en -toepassingen, waaronder die in Databricks.

Zie de OpenAI-documentatie voor meer informatie over het voltooien van chats invoerschema en uitvoerschema.

Notitie

Het voltooiingsschema van de OpenAI-chat is gewoon een standaard voor het structureren van agentinvoer en -uitvoer. Het implementeren van dit schema omvat geen gebruik van openAI-resources of -modellen.

MLflow biedt handige API's voor LangChain- en PyFunc-flavored agents, waarmee u agents kunt maken die compatibel zijn met het voltooiingsschema van de chat.

Chatvoltooiing implementeren met LangChain

Als uw agent LangChain gebruikt, gebruikt u de ChatCompletionOutputParser() van MLflow om de uiteindelijke uitvoer van uw agent op te maken zodat deze compatibel is met het voltooiingsschema van de chat. Als u LangGraph gebruikt, bekijk dan aangepaste schema's van LangGraph.

  from mlflow.langchain.output_parsers import ChatCompletionOutputParser

  chain = (
      {
          "user_query": itemgetter("messages")
          | RunnableLambda(extract_user_query_string),
          "chat_history": itemgetter("messages") | RunnableLambda(extract_chat_history),
      }
      | RunnableLambda(DatabricksChat)
      | ChatCompletionOutputParser()
  )

Voltooiing van chat implementeren met PyFunc

Als u PyFunc gebruikt, raadt Databricks aan om uw agent als subklasse van mlflow.pyfunc.ChatModelte schrijven. Deze methode biedt de volgende voordelen:

• Hiermee kunt u agentcode schrijven die compatibel is met het voltooiingsschema voor chats met behulp van getypte Python-klassen.

• Wanneer de agent wordt geregistreerd, leidt MLflow automatisch een handtekening af die compatibel is met de voltooiing van een chat, zelfs zonder een input_example. Dit vereenvoudigt het proces van het registreren en implementeren van de agent. Zie Modelhandtekening afleiden tijdens logboekregistratie.

  from dataclasses import dataclass
  from typing import Optional, Dict, List, Generator
  from mlflow.pyfunc import ChatModel
  from mlflow.types.llm import (
      # Non-streaming helper classes
      ChatCompletionRequest,
      ChatCompletionResponse,
      ChatCompletionChunk,
      ChatMessage,
      ChatChoice,
      ChatParams,
      # Helper classes for streaming agent output
      ChatChoiceDelta,
      ChatChunkChoice,
  )
  
  class MyAgent(ChatModel):
      """
      Defines a custom agent that processes ChatCompletionRequests
      and returns ChatCompletionResponses.
      """
      def predict(self, context, messages: list[ChatMessage], params: ChatParams) -> ChatCompletionResponse:
          last_user_question_text = messages[-1].content
          response_message = ChatMessage(
              role="assistant",
              content=(
                  f"I will always echo back your last question. Your last question was: {last_user_question_text}. "
              )
          )
          return ChatCompletionResponse(
              choices=[ChatChoice(message=response_message)]
          )
  
      def _create_chat_completion_chunk(self, content) -> ChatCompletionChunk:
          """Helper for constructing a ChatCompletionChunk instance for wrapping streaming agent output"""
          return ChatCompletionChunk(
                  choices=[ChatChunkChoice(
                      delta=ChatChoiceDelta(
                          role="assistant",
                          content=content
                      )
                  )]
              )
  
      def predict_stream(
          self, context, messages: List[ChatMessage], params: ChatParams
      ) -> Generator[ChatCompletionChunk, None, None]:
          last_user_question_text = messages[-1].content
          yield self._create_chat_completion_chunk(f"Echoing back your last question, word by word.")
          for word in last_user_question_text.split(" "):
              yield self._create_chat_completion_chunk(word)
  
  agent = MyAgent()
  model_input = ChatCompletionRequest(
      messages=[ChatMessage(role="user", content="What is Databricks?")]
  )
  response = agent.predict(context=None, model_input=model_input)
  print(response)
  

Aangepaste invoer en uitvoer

Databricks raadt aan om aan het OpenAI-chatvoltooiingsschema te blijven voor de meeste gebruiksscenario's van de agent.

Voor sommige scenario's zijn echter mogelijk extra invoer vereist, zoals client_type en session_id, of uitvoer zoals het ophalen van bronkoppelingen die niet moeten worden opgenomen in de chatgeschiedenis voor toekomstige interacties.

Voor deze scenario's biedt Mosaic AI Agent Framework ondersteuning voor het uitbreiden van aanvragen en antwoorden voor het voltooien van OpenAI-chats met aangepaste invoer en uitvoer.

Zie de volgende voorbeelden voor meer informatie over het maken van aangepaste invoer en uitvoer voor PyFunc- en LangGraph-agents.

Waarschuwing

De agentevaluatie-app ondersteunt momenteel niet de rendering van traceringen voor agenten met extra invoervelden.

Aangepaste PyFunc-schema's

In de volgende notebooks ziet u een aangepast schemavoorbeeld met behulp van PyFunc.

Notebook pyFunc-aangepaste schemaagent

Notebook downloaden

Notebook voor aangepast schemastuurprogramma pyFunc

Notebook downloaden

LangGraph aangepaste schema's

In de volgende notebooks ziet u een aangepast schemaschema voorbeeld behulp van LangGraph. U kunt de functie wrap_output in de notebooks wijzigen om informatie uit de berichtenstroom te parseren en te extraheren.

Aangepaste schemaagentnotitieblok van LangGraph

Notebook downloaden

LangGraph-notebook voor aangepaste schemastuurprogramma's

Notebook downloaden

Opgeven custom_inputs in de AI Playground- en agentbeoordelings-app

Als uw agent aanvullende invoer accepteert met behulp van het veld custom_inputs, kunt u deze invoer handmatig opgeven in zowel de AI Playground als de agent beoordelingsapp .

1. Selecteer in de AI Playground of de app Agent Review het tandwielpictogram .

2. Schakel custom_inputs in.

3. Geef een JSON-object op dat overeenkomt met het gedefinieerde invoerschema van uw agent.

   

Verouderde invoer- en uitvoerschema's

Het invoerschema SplitChatMessageRequest en het stringResponse-uitvoerschema zijn afgeschaft. Als u een van deze verouderde schema's gebruikt, raadt Databricks u aan om te migreren naar het aanbevolen voltooiingsschema voor chats.

SplitChatMessageRequest-invoerschema (afgeschaft)

Met SplitChatMessagesRequest kunt u de huidige query en geschiedenis afzonderlijk doorgeven als agentinvoer.

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

StringResponse-uitvoerschema (afgeschaft)

Met StringResponse kunt u het antwoord van de agent retourneren als een object met een veld van een enkele string content.

{"content": "This is an example string response"}