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. Les étapes suivantes vous expliquent comment créer cette application :

  1. Définir et configurer un modèle
  2. Définir une fonction
  3. Utiliser un agent LangChain pour connecter le modèle à la fonction
  4. Tester l'application

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. Pour créer votre application, vous devez définir le modèle que vous souhaitez utiliser. Pour en savoir plus, consultez la page Versions et cycle de vie des modèles. Exécutez la commande suivante pour utiliser le modèle multimodal Gemini 1.0 Pro Vision.

    model = "gemini-1.0-pro"
    
  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 suivants.

    • Température
    • Nombre maximal de jetons de sortie
    • TopP
    • TopK
    • Paramètres de sécurité (vous devez d'abord créer vos paramètres de sécurité à l'aide de l'étape précédente).

    Pour en savoir plus sur les options disponibles pour les réglages de paramètres de modèle dans Gemini, consultez la page Définir les paramètres de modèle. L'exemple suivant vous montre comment spécifier des paramètres de modèle :

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.
    "top_k": 40,
    # safety_settings (Dict[HarmCategory, HarmBlockThreshold]): The safety
    # settings to use for generating content.
    "safety_settings": safety_settings,
}

Étape 2. Définir une fonction Python

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}}

Étape 3. Utiliser un modèle d'orchestration LangChain

Un framework d'orchestration organise le code de l'application en une ou plusieurs fonctions qui spécifient les paramètres de configuration de l'application, la logique d'initialisation de l'application et la logique d'exécution.

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.

Pour utiliser la classe LangchainAgent, spécifiez le modèle, la fonction définie et les paramètres du modèle pour instancier un objet LangchainAgent :

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

Étape 4. Tester l'application

Maintenant que vous avez créé votre application, il est temps de la tester. 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."}

Étapes suivantes