Créez une application de chat LLM à l’aide de Langgraph, Openai et Python – 2

Alors que nous continuons avec notre application de chat Python, comprenons SystemMessage et comment instruire les modèles à Langchain.

Lisez la partie 1 ici.

Lors de la construction d’une IA conversationnelle avec Langchain, la façon dont vous envoyez des informations et recevez des informations est via des messages. Chaque message a un rôle spécifique, vous aidant à façonner l’écoulement, le ton et le contexte de la conversation.

Langchain prend en charge plusieurs types de messages:

• Mesure humaine – représente l’entrée de l’utilisateur
• AIMessage – représente la réponse du modèle
• SystemMessage – Définit le comportement ou les règles du modèle
• FunctionMessage – stocke la sortie d’une fonction appelée
• Toolsage – tient le résultat d’un outil externe

Dans cet article, nous explorerons SystemMessage Et apprenez à l’utiliser pour guider les réponses d’un modèle. Les messages système sont utilisés pour guider le comportement du modèle de chat et fournir un contexte important pour la conversation.

• C’est une sorte d’instruction au modèle
• C’est une sorte de règles définies pour le modèle
• Il donne le ton du modèle

Ils peuvent donner le ton, définir le rôle de l’assistant ou décrire les règles spécifiques que le modèle doit suivre.

À Langchain, SystemMessage est utilisé aux fins suivantes:

• Rend les réponses du modèle cohérentes
• Établit les limites et les règles de sécurité appropriées
• Donne au modèle une connaissance du domaine spécifique
• Contrôle le style de conversation et le format

Regardons un exemple rapide de l’utilisation d’un SystemMessage. Dans ce cas, nous créons une chaîne qui demande au modèle de fournir des informations uniquement pour les trois villes suivantes.

system_prompt = """
 Only answer question for these cities Delhi, London, and Paris
"""
     SystemMessage(content=system_prompt),
        HumanMessage(content="I am DJ"),
        AIMessage(content="Hello DJ, how can I assist you today?"),
    ]

Le modèle ne doit générer des réponses que sur les trois villes spécifiées dans le SystemMessage. Aménagement le tout, vous pouvez passer le SystemMessage au modèle comme indiqué ci-dessous:

import os
from dotenv import load_dotenv
from openai import OpenAI
from langchain_openai import ChatOpenAI
from langchain.schema import HumanMessage
from langchain_core.messages import AIMessage, SystemMessage

load_dotenv()

system_prompt = """
 Only answer question from these cities Delhi, London, and Paris
"""

model = ChatOpenAI(
            model="gpt-3.5-turbo",
            api_key=os.getenv("OPENAI_API_KEY"),
        )

def chat():
    messages = [
        SystemMessage(content=system_prompt),
        HumanMessage(content="I am DJ"),
        AIMessage(content="Hello DJ, how can I assist you today?"),
    ]

    print('chat started press q to exit.....')
    print('-' *30)

    while True:

        user_input = input("You: ").strip()

        if user_input.lower() in ['q']:
                print("Goodbye!")
                break

        messages.append(HumanMessage(content=user_input))
        response = model.invoke(messages)
        messages.append(response)

        print(f"AI: {response.content}")
        print('-' * 30)

if __name__ == "__main__":
    print(chat())

Lorsque vous exécutez le code, vous devriez voir la réponse du modèle comme indiqué ci-dessous:

Comme vous pouvez le voir, le modèle répond exactement selon les instructions données dans le système SystemMessage.

Standard

Le système de système ci-dessus n’est pas réutilisable car les noms de la ville sont codés en dur. Nous pouvons le rendre réutilisable en utilisant des modèles de messages. Vous pouvez utiliser PromptTemplate.

Le PromptTemplate est utilisé pour un modèle basé sur une chaîne. Au lieu de codage dur dans une invite, vous définissez un modèle avec des espaces réservés, puis remplissez-les dynamiquement au moment de l’exécution.

Vous pouvez créer un simple PromptTemplate Comme indiqué ci-dessous:

template = PromptTemplate.from_template("Tell me a joke about {topic}")
formatted = template.invoke({"topic": "programming"})
print(formatted.text)

model = ChatOpenAI(
            model="gpt-3.5-turbo",
            api_key=os.getenv("OPENAI_API_KEY")
        )

r = model.invoke(template.invoke({"topic": "programming"}))
print(r.content)

Lorsque vous exécutez le code, vous devriez voir la réponse du modèle comme indiqué ci-dessous:

L’exemple de ville précédent peut être refactorisé pour utiliser PromptTemplatepermettant une injection dynamique des noms de la ville lors de l’exécution plutôt que de les coder en dur. La nouvelle implémentation est indiquée ci-dessous:

import os
from dotenv import load_dotenv
from openai import OpenAI
from langchain_openai import ChatOpenAI
from langchain.schema import HumanMessage
from langchain_core.messages import AIMessage, SystemMessage
from langchain_core.prompts import PromptTemplate

load_dotenv()

system_template = PromptTemplate.from_template(
    """
    Only answer question from these cities {cities}. 
    Do not answer any other question about any other city.
    When user asks, about other cities, say that you are only an assistant for these cities.
    """
)

model = ChatOpenAI(
            model="gpt-3.5-turbo",
            api_key=os.getenv("OPENAI_API_KEY")
        )

def chat():
    system_prompt = system_template.invoke({"cities": "Delhi, London, and Paris"}).text
    messages = [
        SystemMessage(content=system_prompt),
        HumanMessage(content="I am DJ"),
        AIMessage(content="Hello DJ, how can I assist you today?"),
    ]

    print('chat started press q to exit.....')
    print('-' *30)

    while True:

        user_input = input("You: ").strip()

        if user_input.lower() in ['q']:
                print("Goodbye!")
                break

        messages.append(HumanMessage(content=user_input))
        response = model.invoke(messages)
        messages.append(response)

        print(f"AI: {response.content}")
        print('-' * 30)

if __name__ == "__main__":
    print(chat())

Lorsque vous exécutez le code, vous devriez voir la réponse du modèle comme indiqué ci-dessous:

Donc, pour résumer, un PromptTemplate est une invite réutilisable qui contient des espaces réservés que vous pouvez remplir au moment de l’exécution. Cette approche évite le codage dur et facilite les invites à réutiliser.

Il prend en charge divers paramètres, que nous explorerons en détail dans les articles ultérieurs. Cependant, deux paramètres clés requis sont:

1. input_variables – une liste de noms de variables dont l’invite aura besoin en tant qu’entrées
2. template – Le texte invite réel, avec des espaces réservés pour ces variables

Nous pouvons modifier le modèle système ci-dessus à utiliser input_variable et modèle comme indiqué ci-dessous:

system_template = PromptTemplate(
    input_variables=["cities", "user_name", "assistant_role"],
    template="""
    You are a {assistant_role} assistant for {user_name}.
    
    IMPORTANT RULES:
    - Only answer questions about these cities: {cities}
    - Do not answer any other question about any other city
    - When user asks about other cities, say that you are only an assistant for these cities: {cities}
    - Always be helpful and provide accurate information
    - Greet the user by name: {user_name}
    """,
    validate_template=True
)

Puis créez l’invite système comme indiqué ci-dessous.

system_prompt = system_template.invoke({
        "cities": "Delhi, London, and Paris",
        "user_name": "DJ",
        "assistant_role": "travel"
    }).text

JSON dans SystemPrompt

Nous allons maintenant combiner tout ce que nous avons appris et demander au modèle de générer une réponse à l’aide d’une chaîne JSON renvoyée d’une API.

Tout d’abord, créons une fonction dans laquelle nous récupérons les données à partir d’un point de terminaison de l’API.

def fetch_data():
     
     try:
          api_url = "http://localhost:3000/product"
          response = requests.get(api_url)

          if response.status_code == 200:
               return response.json()
          else:
            print(f"API call failed with status: {response.status_code}")
            return None

     except Exception as e:

        print(f"Error making API call: {e}")
        return None

Cette fonction renvoie les données JSON, que nous utiliserons comme entrée SystemMessage Pour guider le modèle pour générer des réponses uniquement à partir de ce JSON.

Ensuite, créez un modèle système avec deux paramètres d’entrée et définissez le modèle qui sera utilisé avec le SystemMessage.

system_template = PromptTemplate(
    input_variables=["data", "user_name"],
    template="""
    IMPORTANT RULES:
    - Only answer questions about data: {data}
    - Do not answer any other question about any thing other than data
    - Always be helpful and provide accurate information
    - Greet the user by name: {user_name}
    """,
    validate_template=True
)

Ensuite, créez le SystemPrompt Comme indiqué ci-dessous:

  data = fetch_data()
    system_prompt = system_template.invoke({
        "data": str(data),
        "user_name": "DJ",
    }).text

Ensuite, créez le SystemMessage à utiliser avec le modèle comme indiqué ci-dessous:

   messages = [
        SystemMessage(content=system_prompt),
        HumanMessage(content="I am DJ"),
        AIMessage(content="Hello DJ, how can I assist you today?"),
    ]

Le tout ensemble, nous pouvons construire un chatbot qui utilise un SystemMessage et les données JSON d’une API, comme indiqué dans le code ci-dessous.

import os
from dotenv import load_dotenv
from openai import OpenAI
import requests
from langchain_openai import ChatOpenAI
from langchain.schema import HumanMessage
from langchain_core.messages import AIMessage, SystemMessage
from langchain_core.prompts import PromptTemplate

load_dotenv()

def fetch_data():
     
     try:
          api_url = "http://localhost:3000/product"
          response = requests.get(api_url)

          if response.status_code == 200:
               return response.json()
          else:
            print(f"API call failed with status: {response.status_code}")
            return None

     except Exception as e:

        print(f"Error making API call: {e}")
        return None

system_template = PromptTemplate(
    input_variables=["data", "user_name"],
    template="""
    IMPORTANT RULES:
    - Only answer questions about data: {data}
    - Do not answer any other question about any thing other than data
    - Always be helpful and provide accurate information
    - Greet the user by name: {user_name}
    """,
    validate_template=True
)

model = ChatOpenAI(
            model="gpt-3.5-turbo",
            api_key=os.getenv("OPENAI_API_KEY")
        )

def chat():
    data = fetch_data()
    system_prompt = system_template.invoke({
        "data": str(data),
        "user_name": "DJ",
    }).text
     
    messages = [
        SystemMessage(content=system_prompt),
        HumanMessage(content="I am DJ"),
        AIMessage(content="Hello DJ, how can I assist you today?"),
    ]

    print('chat started press q to exit.....')
    print('-' *30)

    while True:

        user_input = input("You: ").strip()

        if user_input.lower() in ['q']:
                print("Goodbye!")
                break

        messages.append(HumanMessage(content=user_input))
        response = model.invoke(messages)
        messages.append(response)

        print(f"AI: {response.content}")
        print('-' * 30)

if __name__ == "__main__":
    print(chat())

Lorsque vous exécutez le code, vous devriez pouvoir discuter et recevoir des réponses liées au produit, comme indiqué ci-dessous.

Résumé

Dans cet article, nous avons exploré SystemMessage et comment l’utiliser pour guider un modèle vers la réponse souhaitée. Nous avons également couvert PromptTemplate et comment utiliser une réponse API comme ensemble de données. J’espère que vous avez trouvé cet article utile. Merci d’avoir lu.