Développer une application

Un exemple de petite application que vous pouvez créer à l'aide de LangChain sur Vertex AI est une application qui renvoie le taux de change entre deux devises à une date donnée.

Vous pouvez définir votre propre classe Python (consultez la section Personnaliser un modèle d'application) ou utiliser la classe LangchainAgent du SDK Vertex AI pour Python pour votre agent. Les étapes suivantes vous expliquent comment créer cette application à l'aide du modèle prédéfini LangchainAgent :

1. Définir et configurer un modèle
2. Définir et utiliser un outil
3. (Facultatif) Stocker l'historique des discussions
4. (Facultatif) Personnaliser le modèle de requête
5. (Facultatif) Personnaliser l'orchestration

Avant de commencer

Avant d'exécuter ce tutoriel, assurez-vous que votre environnement est configuré en suivant la procédure décrite dans la section Configurer votre environnement.

Étape 1. Définir et configurer un modèle

Exécutez les étapes suivantes pour définir et configurer votre modèle :

1. Vous devez définir la version de modèle à utiliser.

   model = "gemini-1.5-flash-001"
   

2. (Facultatif) Vous pouvez configurer les paramètres de sécurité du modèle. Pour en savoir plus sur les options disponibles pour configurer les paramètres de sécurité dans Gemini, consultez la section Configurer les attributs de sécurité.

   Voici un exemple de configuration des paramètres de sécurité :

   from langchain_google_vertexai import HarmBlockThreshold, HarmCategory
   
   safety_settings = {
       HarmCategory.HARM_CATEGORY_UNSPECIFIED: HarmBlockThreshold.BLOCK_NONE,
       HarmCategory.HARM_CATEGORY_DANGEROUS_CONTENT: HarmBlockThreshold.BLOCK_MEDIUM_AND_ABOVE,
       HarmCategory.HARM_CATEGORY_HATE_SPEECH: HarmBlockThreshold.BLOCK_ONLY_HIGH,
       HarmCategory.HARM_CATEGORY_HARASSMENT: HarmBlockThreshold.BLOCK_LOW_AND_ABOVE,
       HarmCategory.HARM_CATEGORY_SEXUALLY_EXPLICIT: HarmBlockThreshold.BLOCK_NONE,
   }
   

3. (Facultatif) Vous pouvez spécifier les paramètres de modèle de la manière suivante:

   model_kwargs = {
       # temperature (float): The sampling temperature controls the degree of
       # randomness in token selection.
       "temperature": 0.28,
       # max_output_tokens (int): The token limit determines the maximum amount of
       # text output from one prompt.
       "max_output_tokens": 1000,
       # top_p (float): Tokens are selected from most probable to least until
       # the sum of their probabilities equals the top-p value.
       "top_p": 0.95,
       # top_k (int): The next token is selected from among the top-k most
       # probable tokens. This is not supported by all model versions. See
       # https://cloud.google.com/vertex-ai/generative-ai/docs/multimodal/image-understanding#valid_parameter_values
       # for details.
       "top_k": None,
       # safety_settings (Dict[HarmCategory, HarmBlockThreshold]): The safety
       # settings to use for generating content.
       # (you must create your safety settings using the previous step first).
       "safety_settings": safety_settings,
   }
   

Vous pouvez désormais créer et interroger un LangchainAgent à l'aide des configurations de modèle :

agent = reasoning_engines.LangchainAgent(
    model=model,                # Required.
    model_kwargs=model_kwargs,  # Optional.
)

response = agent.query(input="What is the exchange rate from US dollars to Swedish currency?")

La réponse est un dictionnaire Python semblable à l'exemple suivant:

{"input": "What is the exchange rate from US dollars to Swedish currency?",
 "output": """I cannot provide the live exchange rate from US dollars to Swedish currency (Swedish krona, SEK).

**Here's why:**

* **Exchange rates constantly fluctuate.** Factors like global economics, interest rates, and political events cause
  these changes throughout the day.
* **Providing inaccurate information would be misleading.**

**How to find the current exchange rate:**

1. **Use a reliable online converter:** Many websites specialize in live exchange rates. Some popular options include:
   * Google Finance (google.com/finance)
   * XE.com
   * Bank websites (like Bank of America, Chase, etc.)
2. **Contact your bank or financial institution:** They can give you the exact exchange rate they are using.

Remember to factor in any fees or commissions when exchanging currency.
"""}

Remarque : La réponse indique que l'agent ne peut pas fournir le taux de change. Lorsque l'agent est équipé d'un outil de taux de change, il effectue un appel de fonction pour utiliser l'outil et fournir une meilleure réponse.

(Facultatif) Personnalisation avancée

Le modèle LangchainAgent utilise ChatVertexAI par défaut, car il permet d'accéder à tous les modèles de base disponibles dans Google Cloud. Pour utiliser un modèle non disponible via ChatVertexAI, vous pouvez spécifier l'argument model_builder= avec une fonction Python de la signature suivante:

from typing import Optional

def model_builder(
    *,
    model_name: str,                      # Required. The name of the model
    model_kwargs: Optional[dict] = None,  # Optional. The model keyword arguments.
    **kwargs,                             # Optional. The remaining keyword arguments to be ignored.
):

Pour obtenir la liste des modèles de chat compatibles avec LangChain et de leurs fonctionnalités, consultez la page Modèles de chat. L'ensemble des valeurs acceptées pour model= et model_kwargs= est spécifique à chaque modèle de chat. Vous devez donc vous reporter à la documentation correspondante pour plus de détails.

ChatVertexAI

Installé par défaut.

Il est utilisé dans le modèle LangchainAgent lorsque vous omettez l'argument model_builder. Par exemple :

agent = reasoning_engines.LangchainAgent(
    model=model,                # Required.
    model_kwargs=model_kwargs,  # Optional.
)

ChatAnthropic

Commencez par suivre la documentation pour configurer un compte et installer le package.

Ensuite, définissez un model_builder qui renvoie ChatAnthropic :

def model_builder(*, model_name: str, model_kwargs = None, **kwargs):
    from langchain_anthropic import ChatAnthropic
    return ChatAnthropic(model_name=model_name, **model_kwargs)

Enfin, utilisez-le dans le modèle LangchainAgent avec le code suivant :

agent = reasoning_engines.LangchainAgent(
    model="claude-3-opus-20240229",                       # Required.
    model_builder=model_builder,                          # Required.
    model_kwargs={
        "api_key": "ANTHROPIC_API_KEY",  # Required.
        "temperature": 0.28,                              # Optional.
        "max_tokens": 1000,                               # Optional.
    },
)

ChatOpenAI

Vous pouvez utiliser ChatOpenAI conjointement avec l'API ChatCompletions de Gemini.

Commencez par suivre la documentation pour installer le package.

Ensuite, définissez un model_builder qui renvoie ChatOpenAI :

def model_builder(
    *,
    model_name: str,
    model_kwargs = None,
    project: str,   # Specified via vertexai.init
    location: str,  # Specified via vertexai.init
    **kwargs,
):
    import google.auth
    from langchain_openai import ChatOpenAI

    # Note: the credential lives for 1 hour by default.
    # After expiration, it must be refreshed.
    creds, _ = google.auth.default(scopes=["https://www.googleapis.com/auth/cloud-platform"])
    auth_req = google.auth.transport.requests.Request()
    creds.refresh(auth_req)

    if model_kwargs is None:
        model_kwargs = {}

    endpoint = f"https://{location}-aiplatform.googleapis.com"
    base_url = f'{endpoint}/v1beta1/projects/{project}/locations/{location}/endpoints/openapi'

    return ChatOpenAI(
        model=model_name,
        base_url=base_url,
        **model_kwargs,
    )

Enfin, utilisez-le dans le modèle LangchainAgent avec le code suivant :

agent = reasoning_engines.LangchainAgent(
    model="google/gemini-1.5-pro-001",  # Or "meta/llama3-405b-instruct-maas"
    model_builder=model_builder,        # Required.
    model_kwargs={
        "temperature": 0,               # Optional.
        "max_retries": 2,               # Optional.
    },
)

Étape 2 : Définir et utiliser un outil

Une fois votre modèle défini, l'étape suivante consiste à définir les outils qu'il utilise pour le raisonnement. Un outil peut être un outil LangChain ou une fonction Python. Vous pouvez également convertir une fonction Python définie en outil LangChain. Cette application utilise une définition de fonction.

Lorsque vous définissez votre fonction, il est important d'inclure des commentaires qui décrivent pleinement et clairement les paramètres de la fonction, ce qu'elle fait et ce qu'elle renvoie. Le modèle utilise ces informations pour déterminer quelle fonction utiliser. Vous devez également tester votre fonction localement pour vérifier qu'elle fonctionne.

Utilisez le code suivant pour définir une fonction qui renvoie un taux de change :

def get_exchange_rate(
    currency_from: str = "USD",
    currency_to: str = "EUR",
    currency_date: str = "latest",
):
    """Retrieves the exchange rate between two currencies on a specified date.

    Uses the Frankfurter API (https://api.frankfurter.app/) to obtain
    exchange rate data.

    Args:
        currency_from: The base currency (3-letter currency code).
            Defaults to "USD" (US Dollar).
        currency_to: The target currency (3-letter currency code).
            Defaults to "EUR" (Euro).
        currency_date: The date for which to retrieve the exchange rate.
            Defaults to "latest" for the most recent exchange rate data.
            Can be specified in YYYY-MM-DD format for historical rates.

    Returns:
        dict: A dictionary containing the exchange rate information.
            Example: {"amount": 1.0, "base": "USD", "date": "2023-11-24",
                "rates": {"EUR": 0.95534}}
    """
    import requests
    response = requests.get(
        f"https://api.frankfurter.app/{currency_date}",
        params={"from": currency_from, "to": currency_to},
    )
    return response.json()

Pour tester la fonction avant de l'utiliser dans votre application, exécutez la commande suivante :

get_exchange_rate(currency_from="USD", currency_to="SEK")

La sortie devrait ressembler à ce qui suit :

{'amount': 1.0, 'base': 'USD', 'date': '2024-02-22', 'rates': {'SEK': 10.3043}}

Pour utiliser l'outil dans le modèle LangchainAgent, vous devez l'ajouter à la liste des outils sous l'argument tools=:

agent = reasoning_engines.LangchainAgent(
    model=model,                # Required.
    tools=[get_exchange_rate],  # Optional.
    model_kwargs=model_kwargs,  # Optional.
)

Vous pouvez tester l'application en envoyant des requêtes de test. Exécutez la commande suivante pour tester l'application en utilisant le dollar américain et la couronne suédoise :

response = agent.query(
    input="What is the exchange rate from US dollars to Swedish currency?"
)

La réponse est un dictionnaire semblable à celui-ci:

{"input": "What is the exchange rate from US dollars to Swedish currency?",
 "output": "For 1 US dollar you will get 10.7345 Swedish Krona."}

(Facultatif) Plusieurs outils

Les outils pour LangchainAgent peuvent être définis et instanciés de différentes manières.

Outil d'ancrage

Commencez par importer le package generate_models et créer l'outil.

from vertexai.generative_models import grounding, Tool

grounded_search_tool = Tool.from_google_search_retrieval(
    grounding.GoogleSearchRetrieval()
)

Ensuite, utilisez l'outil dans le modèle LangchainAgent :

agent = reasoning_engines.LangchainAgent(
    model=model,
    tools=[grounded_search_tool],
)
agent.query(input="When is the next total solar eclipse in US?")

La réponse est un dictionnaire semblable à celui-ci:

{"input": "When is the next total solar eclipse in US?",
 "output": """The next total solar eclipse in the U.S. will be on August 23, 2044.
 This eclipse will be visible from three states: Montana, North Dakota, and
 South Dakota. The path of totality will begin in Greenland, travel through
 Canada, and end around sunset in the United States."""}

Pour en savoir plus, consultez la section Ancrage.

Outil LangChain

Commencez par installer le package qui définit l'outil.

pip install langchain-google-community

Importez ensuite le package et créez l'outil.

from langchain_google_community import VertexAISearchRetriever
from langchain.tools.retriever import create_retriever_tool

retriever = VertexAISearchRetriever(
    project_id="PROJECT_ID",
    data_store_id="DATA_STORE_ID",
    location_id="DATA_STORE_LOCATION_ID",
    engine_data_type=1,
    max_documents=10,
)
movie_search_tool = create_retriever_tool(
    retriever=retriever,
    name="search_movies",
    description="Searches information about movies.",
)

Enfin, utilisez l'outil dans le modèle LangchainAgent:

agent = reasoning_engines.LangchainAgent(
    model=model,
    tools=[movie_search_tool],
)
response = agent.query(
    input="List some sci-fi movies from the 1990s",
)

Il doit renvoyer une réponse telle que

{"input": "When is the next total solar eclipse in US?",
 "output": """Here are some sci-fi movies from the 1990s:
    * The Matrix (1999): A computer hacker learns from mysterious rebels about the true nature of his reality and his role in the war against its controllers.
    * Star Wars: Episode I - The Phantom Menace (1999): Two Jedi Knights escape a hostile blockade to find a queen and her protector, and come across a young boy [...]
    * Men in Black (1997): A police officer joins a secret organization that monitors extraterrestrial interactions on Earth.
    [...]
 """}

Pour voir l'exemple complet, consultez le notebook.

Pour en savoir plus sur les outils disponibles dans LangChain, consultez Outils Google.

Extension Vertex AI

Commencez par importer le package d'extensions et créez l'outil.

from typing import Optional

def generate_and_execute_code(
    query: str,
    files: Optional[list[str]] = None,
    file_gcs_uris: Optional[list[str]] = None,
) -> str:
    """Get the results of a natural language query by generating and executing
    a code snippet.

    Example queries: "Find the max in [1, 2, 5]" or "Plot average sales by
    year (from data.csv)". Only one of `file_gcs_uris` and `files` field
    should be provided.

    Args:
        query:
            The natural language query to generate and execute.
        file_gcs_uris:
            Optional. URIs of input files to use when executing the code
            snippet. For example, ["gs://input-bucket/data.csv"].
        files:
            Optional. Input files to use when executing the generated code.
            If specified, the file contents are expected be base64-encoded.
            For example: [{"name": "data.csv", "contents": "aXRlbTEsaXRlbTI="}].
    Returns:
        The results of the query.
    """
    operation_params = {"query": query}
    if files:
        operation_params["files"] = files
    if file_gcs_uris:
        operation_params["file_gcs_uris"] = file_gcs_uris

    from vertexai.preview import extensions

    # If you have an existing extension instance, you can get it here
    # i.e. code_interpreter = extensions.Extension(resource_name).
    code_interpreter = extensions.Extension.from_hub("code_interpreter")
    return extensions.Extension.from_hub("code_interpreter").execute(
        operation_id="generate_and_execute",
        operation_params=operation_params,
    )

Ensuite, utilisez l'outil dans le modèle LangchainAgent:

agent = reasoning_engines.LangchainAgent(
    model=model,
    tools=[generate_and_execute_code],
)
agent.query(
    input="""Using the data below, construct a bar chart that includes only the height values with different colors for the bars:

    tree_heights_prices = {
      \"Pine\": {\"height\": 100, \"price\": 100},
      \"Oak\": {\"height\": 65, \"price\": 135},
      \"Birch\": {\"height\": 45, \"price\": 80},
      \"Redwood\": {\"height\": 200, \"price\": 200},
      \"Fir\": {\"height\": 180, \"price\": 162},
    }
    """
)

Vous devriez obtenir une réponse semblable à

{"input": """Using the data below, construct a bar chart that includes only the height values with different colors for the bars:

 tree_heights_prices = {
    \"Pine\": {\"height\": 100, \"price\": 100},
    \"Oak\": {\"height\": 65, \"price\": 135},
    \"Birch\": {\"height\": 45, \"price\": 80},
    \"Redwood\": {\"height\": 200, \"price\": 200},
    \"Fir\": {\"height\": 180, \"price\": 162},
 }
 """,
 "output": """Here's the generated bar chart:
 ```python
 import matplotlib.pyplot as plt

 tree_heights_prices = {
    "Pine": {"height": 100, "price": 100},
    "Oak": {"height": 65, "price": 135},
    "Birch": {"height": 45, "price": 80},
    "Redwood": {"height": 200, "price": 200},
    "Fir": {"height": 180, "price": 162},
 }

 heights = [tree["height"] for tree in tree_heights_prices.values()]
 names = list(tree_heights_prices.keys())

 plt.bar(names, heights, color=['red', 'green', 'blue', 'purple', 'orange'])
 plt.xlabel('Tree Species')
 plt.ylabel('Height')
 plt.title('Tree Heights')
 plt.show()
 ```
 """}

Pour en savoir plus, consultez la page Extensions Vertex AI.

Vous pouvez utiliser tous les outils (ou un sous-ensemble) que vous avez créés dans LangchainAgent:

agent = reasoning_engines.LangchainAgent(
    model=model,
    tools=[
        get_exchange_rate,         # Optional (Python function)
        grounded_search_tool,      # Optional (Grounding Tool)
        movie_search_tool,         # Optional (Langchain Tool)
        generate_and_execute_code, # Optional (Vertex Extension)
    ],
)

agent.query(input="When is the next total solar eclipse in US?")

(Facultatif) Configuration de l'outil

Avec Gemini, vous pouvez imposer des contraintes sur l'utilisation de l'outil. Par exemple, au lieu d'autoriser le modèle à générer des réponses en langage naturel, vous pouvez l'obliger à ne générer que des appels de fonction ("appel de fonction forcée").

from vertexai.preview.generative_models import ToolConfig

agent = reasoning_engines.LangchainAgent(
    model="gemini-1.5-pro",
    tools=[search_arxiv, get_exchange_rate],
    model_tool_kwargs={
        "tool_config": {  # Specify the tool configuration here.
            "function_calling_config": {
                "mode": ToolConfig.FunctionCallingConfig.Mode.ANY,
                "allowed_function_names": ["search_arxiv", "get_exchange_rate"],
            },
        },
    },
)

agent.query(
    input="Explain the Schrodinger equation in a few sentences",
)

Pour en savoir plus, consultez Configuration de l'outil.

Étape 3 : Stocker l'historique des discussions

Pour suivre les messages de chat et les ajouter à une base de données, définissez une fonction get_session_history et transmettez-la lors de la création de l'agent. Cette fonction doit accepter un objet session_id et renvoyer un objet BaseChatMessageHistory.

• session_id est un identifiant de la session à laquelle appartiennent ces messages d'entrée. Cela vous permet de conserver plusieurs conversations en même temps.
• BaseChatMessageHistory est l'interface des classes pouvant charger et enregistrer des objets de message.

Configurer une base de données

Pour obtenir la liste des fournisseurs ChatMessageHistory de Google compatibles avec LangChain, consultez la section Mémoire.

Firestore (natif)

Tout d'abord, suivez la documentation de LangChain pour configurer une base de données et installer le package.

Ensuite, définissez une fonction get_session_history comme suit :

def get_session_history(session_id: str):
    from langchain_google_firestore import FirestoreChatMessageHistory
    from google.cloud import firestore

    client = firestore.Client(project="PROJECT_ID")
    return FirestoreChatMessageHistory(
        client=client,
        session_id=session_id,
        collection="TABLE_NAME",
        encode_message=False,
    )

Créez l'agent et transmettez-le en tant que chat_history:

agent = reasoning_engines.LangchainAgent(
    model=model,
    chat_history=get_session_history,  # <- new
)

Bigtable

Commencez par suivre la documentation de LangChain pour configurer une base de données et installer le package.

Ensuite, définissez une fonction get_session_history comme suit :

def get_session_history(session_id: str):
    from langchain_google_bigtable import BigtableChatMessageHistory

    return BigtableChatMessageHistory(
        instance_id="INSTANCE_ID",
        table_id="TABLE_NAME",
        session_id=session_id,
    )

Créez l'agent et transmettez-le en tant que chat_history:

agent = reasoning_engines.LangchainAgent(
    model=model,
    chat_history=get_session_history,  # <- new
)

Spanner

Commencez par suivre la documentation de LangChain pour configurer une base de données et installer le package.

Ensuite, définissez une fonction get_session_history comme suit :

def get_session_history(session_id: str):
    from langchain_google_spanner import SpannerChatMessageHistory

    return SpannerChatMessageHistory(
        instance_id="INSTANCE_ID",
        database_id="DATABASE_ID",
        table_name="TABLE_NAME",
        session_id=session_id,
    )

Créez l'agent et transmettez-le en tant que chat_history:

agent = reasoning_engines.LangchainAgent(
    model=model,
    chat_history=get_session_history,  # <- new
)

Lorsque vous interrogez l'agent, veillez à transmettre le session_id afin qu'il se souvienne des questions et réponses précédentes :

agent.query(
    input="What is the exchange rate from US dollars to Swedish currency?",
    config={"configurable": {"session_id": "SESSION_ID"}},
)

Étape 4. Personnaliser le modèle de requête

Les modèles de requêtes permettent de traduire les entrées utilisateur en instructions pour un modèle. Ils sont utilisés pour guider la réponse d'un modèle, l'aider à comprendre le contexte et à générer une sortie basée sur le langage pertinente et cohérente. Pour en savoir plus, consultez la section ChatPromptTemplates.

Le modèle de requête par défaut est organisé de manière séquentielle en sections.

Section	Description
(Facultatif) Instructions système	Instructions permettant d'appliquer l'agent à toutes les requêtes.
(Facultatif) Historique des discussions	Messages correspondant à l'historique des discussions d'une session passée.
Entrée utilisateur	Requête de l'utilisateur à laquelle l'agent doit répondre.
Bloc-notes de l'agent	Messages créés par l'agent (par exemple, avec un appel de fonction) lorsqu'il utilise ses outils et effectue un raisonnement pour formuler une réponse à l'utilisateur.

Le modèle de requête par défaut est généré si vous créez l'agent sans spécifier votre propre modèle de requête et se présente entièrement comme suit:

from langchain_core.prompts import ChatPromptTemplate
from langchain.agents.format_scratchpad.tools import format_to_tool_messages

prompt_template = {
    "user_input": lambda x: x["input"],
    "history": lambda x: x["history"],
    "agent_scratchpad": lambda x: format_to_tool_messages(x["intermediate_steps"]),
} | ChatPromptTemplate.from_messages([
    ("system", "{system_instruction}"),
    ("placeholder", "{history}"),
    ("user", "{user_input}"),
    ("placeholder", "{agent_scratchpad}"),
])

Vous pouvez remplacer le modèle de requête par défaut par votre propre modèle de requête et l'utiliser lors de la création de l'agent:

agent = reasoning_engines.LangchainAgent(
    model=model,
    prompt=prompt_template,                        # <- (optional) created above
    system_instruction="You are a helpful agent",  # <- new
    chat_history=get_session_history,
    tools=[get_exchange_rate],
)

agent.query(
    input="What is the exchange rate from US dollars to Swedish currency?",
    config={"configurable": {"session_id": "SESSION_ID"}},
)

Étape 5 : Personnaliser l'orchestration

Tous les composants LangChain implémentent l'interface exécutable, qui fournit des schémas d'entrée et de sortie pour l'orchestration. Le LangchainAgent nécessite la création d'un exécutable pour qu'il puisse répondre aux requêtes. Par défaut, LangchainAgent crée un tel exécutable en liant le modèle à des outils et en utilisant un AgentExecutor encapsulé dans un RunnableWithMessageHistory si l'historique des discussions est activé.

Vous pouvez personnaliser l'orchestration si vous souhaitez (i) implémenter un agent qui exécute un ensemble déterministe d'étapes (plutôt que d'effectuer un raisonnement ouvert) ou (ii) inviter l'agent à annoter chaque étape avec des réflexions sur la raison pour laquelle il a effectué cette étape, comme dans ReAct. Pour ce faire, vous devez remplacer l'exécutable par défaut lors de la création du fichier LangchainAgent en spécifiant l'argument runnable_builder= avec une fonction Python de signature suivante:

from typing import Optional
from langchain_core.language_models import BaseLanguageModel

def runnable_builder(
    model: BaseLanguageModel,
    *,
    system_instruction: Optional[str] = None,
    prompt: Optional["RunnableSerializable"] = None,
    tools: Optional[Sequence["_ToolLike"]] = None,
    chat_history: Optional["GetSessionHistoryCallable"] = None,
    model_tool_kwargs: Optional[Mapping[str, Any]] = None,
    agent_executor_kwargs: Optional[Mapping[str, Any]] = None,
    runnable_kwargs: Optional[Mapping[str, Any]] = None,
    **kwargs,
):

Où :

• model correspond au modèle de chat renvoyé par model_builder (consultez la section Définir et configurer un modèle).
• tools et model_tool_kwargs correspondent aux outils et aux configurations à utiliser (voir Définir et utiliser un outil).
• chat_history correspond à la base de données permettant de stocker les messages de chat (consultez la section Historique des discussions du magasin).
• system_instruction et prompt correspondent à la configuration de la requête (consultez la section Personnaliser le modèle de requête).
• agent_executor_kwargs et runnable_kwargs sont les arguments de mot clé que vous pouvez utiliser pour personnaliser le fichier exécutable à créer.

Vous disposez ainsi de différentes options pour personnaliser la logique d'orchestration.

ChatModel

Dans le cas le plus simple, pour créer un agent sans orchestration, vous pouvez remplacer runnable_builder pour LangchainAgent afin de renvoyer directement le model.

from langchain_core.language_models import BaseLanguageModel

def llm_builder(model: BaseLanguageModel, **kwargs):
    return model

agent = reasoning_engines.LangchainAgent(
    model=model,
    runnable_builder=llm_builder,
)

ReAct

Pour remplacer le comportement d'appel d'outil par défaut par votre propre agent ReAct basé sur votre propre prompt (voir Personnaliser le modèle d'invite), vous devez remplacer runnable_builder par LangchainAgent.

from typing import Sequence
from langchain_core.language_models import BaseLanguageModel
from langchain_core.prompts import BasePromptTemplate
from langchain_core.tools import BaseTool
from langchain import hub

def react_builder(
    model: BaseLanguageModel,
    *,
    tools: Sequence[BaseTool],
    prompt: BasePromptTemplate,
    agent_executor_kwargs = None,
    **kwargs,
):
    from langchain.agents.react.agent import create_react_agent
    from langchain.agents import AgentExecutor

    agent = create_react_agent(model, tools, prompt)
    return AgentExecutor(agent=agent, tools=tools, **agent_executor_kwargs)

agent = reasoning_engines.LangchainAgent(
    model=model,
    tools=[get_exchange_rate],
    prompt=hub.pull("hwchase17/react"),
    agent_executor_kwargs={"verbose": True}, # Optional. For illustration.
    runnable_builder=react_builder,
)

Syntaxe LCEL

Pour construire le graphe suivant en utilisant le langage d'expression LangChain (LCEL),

   Input
   /   \
 Pros  Cons
   \   /
  Summary

vous devez remplacer runnable_builder pour LangchainAgent:

def lcel_builder(*, model, **kwargs):
    from operator import itemgetter
    from langchain_core.prompts import ChatPromptTemplate
    from langchain_core.runnables import RunnablePassthrough
    from langchain_core.output_parsers import StrOutputParser

    output_parser = StrOutputParser()

    planner = ChatPromptTemplate.from_template(
        "Generate an argument about: {input}"
    ) | model | output_parser | {"argument": RunnablePassthrough()}

    pros = ChatPromptTemplate.from_template(
        "List the positive aspects of {argument}"
    ) | model | output_parser

    cons = ChatPromptTemplate.from_template(
        "List the negative aspects of {argument}"
    ) | model | output_parser

    final_responder = ChatPromptTemplate.from_template(
        "Argument:{argument}\nPros:\n{pros}\n\nCons:\n{cons}\n"
        "Generate a final response given the critique",
    ) | model | output_parser

    return planner | {
        "pros": pros,
        "cons": cons,
        "argument": itemgetter("argument"),
    } | final_responder

agent = reasoning_engines.LangchainAgent(
    model=model,
    runnable_builder=lcel_builder,
)

LangGraph

Pour créer le graphique suivant à l'aide de LangGraph,

   Input
   /   \
 Pros  Cons
   \   /
  Summary

vous devez remplacer runnable_builder pour LangchainAgent:

def langgraph_builder(*, model, **kwargs):
    from langchain_core.prompts import ChatPromptTemplate
    from langchain_core.output_parsers import StrOutputParser
    from langgraph.graph import END, MessageGraph

    output_parser = StrOutputParser()

    planner = ChatPromptTemplate.from_template(
        "Generate an argument about: {input}"
    ) | model | output_parser

    pros = ChatPromptTemplate.from_template(
        "List the positive aspects of {input}"
    ) | model | output_parser

    cons = ChatPromptTemplate.from_template(
        "List the negative aspects of {input}"
    ) | model | output_parser

    summary = ChatPromptTemplate.from_template(
        "Input:{input}\nGenerate a final response given the critique",
    ) | model | output_parser

    builder = MessageGraph()
    builder.add_node("planner", planner)
    builder.add_node("pros", pros)
    builder.add_node("cons", cons)
    builder.add_node("summary", summary)

    builder.add_edge("planner", "pros")
    builder.add_edge("planner", "cons")
    builder.add_edge("pros", "summary")
    builder.add_edge("cons", "summary")
    builder.add_edge("summary", END)
    builder.set_entry_point("planner")
    return builder.compile()

agent = reasoning_engines.LangchainAgent(
    model=model,
    runnable_builder=langgraph_builder,
)

# Example query
agent.query(input={"role": "user", "content": "scrum methodology"})

Étape suivante

• Déployez l'application.
• Personnaliser un modèle d'application.