Créez vos nouvelles personnalisées à l'aide d'agents d'IA

Introduction

Les capacités des modèles de grands langues (LLM) progressent rapidement. Ils nous permettent de construire une variété d'applications LLM. Celles-ci vont de l'automatisation des tâches à l'optimisation du flux de travail. Une application passionnante consiste à utiliser LLMS pour créer un agent de digest de nouvelles intelligent ou de newsletter. Cet agent peut attirer le contenu pertinent, le résumer et le livrer dans un format personnalisé. Il peut interagir dynamiquement avec des outils externes et des sources de données pour récupérer des informations pertinentes. Dans cet article, apprenons comment construire un agent de digest de nouvelles pour un digest de nouvelles quotidiennes personnalisé avec Langgraph et des outils externes comme l'API News.

Aperçu

• Comprenez l'architecture de Langgraph et ses composantes clés (état, nœuds et bords) pour créer des agents de flux de travail personnalisables.
• Apprenez à intégrer des API externes comme Newsapi pour récupérer des données en temps réel pour la génération de contenu dynamique dans les newsletters.
• Développer les compétences nécessaires pour utiliser les LLM pour l'évaluation du contenu en mettant en œuvre un système de notation qui classe les articles de presse en fonction des critères de qualité.
• Gardez une connaissance pratique de l'automatisation de la livraison des e-mails avec du contenu organisé à l'aide des bibliothèques en fin de courrier électronique de Python.

Table des matières

• Brief sur Langgraph
• Condition préalable
• Définir le flux d'application
  • Obtenir des nouvelles
  • Marquer des nouvelles
  • Envoyer un e-mail
• Construire l'agent
• Questions fréquemment posées

Brief sur Langgraph

Langgraph est construit sur Langchain. Langgraph est un cadre conçu pour construire des workflows dynamiques qui intègrent les LLM avec une logique et des outils personnalisés. Cela permet des flux de travail hautement personnalisés et complexes qui combinent plusieurs outils et API.

Langgraph se compose de trois composants principaux:

1. État: L'état contient les données partagées tout au long de l'application. Il peut s'agir de n'importe quelle structure de données Python qui peut maintenir les données. Nous pouvons le définir à l'aide d'un objet d'état avec différents paramètres. Alternativement, nous pouvons également utiliser MessageSsTate pré-construit qui ne peut contenir qu'une liste de messages.
2. NODES: Les nœuds sont des fonctions qui peuvent lire et modifier l'état. Ces fonctions prennent l'état comme le premier argument à lire ou à écrire à l'état. Nous avons également un nœud de démarrage pour indiquer quel nœud prendra l'entrée de l'utilisateur et sera appelé d'abord et un nœud final pour indiquer la fin du graphique.
3. EDGES: Les bords définissent le flux de données à travers différents nœuds. Nous avons également des bords conditionnels qui utilisent une fonction pour déterminer le nœud à suivre. L'avantage de Langgraph est que nous pouvons personnaliser l'agent à bien des égards. Il peut donc y avoir plus d'une façon de construire cet agent.

Comme indiqué dans l'image, les bords connectent les nœuds et les nœuds lisent ou écrivent les données dans l'état.

Lisez également: Optimisez le marketing par e-mail de votre organisation avec les agents Genai

Condition préalable

Avant de commencer à construire l'agent LLM, assurez-vous que nous avons les clés et les mots de passe requis.

Accéder à un LLM via l'API

Commencez par générer une clé API pour le LLM que vous utilisez. Créez un fichier texte avec le nom '.env'. Stockez cette clé en toute sécurité dans un fichier .env pour le garder privé et facilement accessible dans votre projet.

Voici un exemple de l'apparence d'un fichier .env

Rechercher des données d'actualités

Pour rassembler du contenu d'actualités, nous utiliserons https://newsapi.org/. Inscrivez-vous à une clé API et stockez-le dans le même fichier .env pour un accès sécurisé.

Envoi de l'e-mail

Pour envoyer un e-mail à l'aide de Python, nous pouvons activer les «applications moins sécurisées» et stocker le mot de passe Gmail dans le fichier .env. Si cette option n'est pas disponible, nous pouvons accéder à Gmail en suivant les étapes mentionnées ici.

Bibliothèques requises

Nous avons utilisé les versions suivantes pour les grandes bibliothèques:

• Langchain - 0.2.14
• Langgraph - 0.2.14
• Langchain-openai - 0.1.14
• Newsapi-Python - 0.2.7

Définir le flux d'application

L'objectif est d'interroger l'agent en utilisant le langage naturel pour rassembler des nouvelles sur un sujet spécifique et de recevoir la newsletter par e-mail. Pour implémenter ce flux, nous définirons d'abord trois outils pour gérer chaque tâche de clé, puis construire l'agent pour appeler le LLM et les outils.

Les trois outils sont les suivants:

1. Récupérer les nouvelles: L'API des nouvelles récupère des articles de presse pertinents basés sur la requête analysée.
2. Marquer les nouvelles: les articles récupérés sont transmis à un autre LLM, qui les évalue et les marque pour la qualité. La sortie est une liste d'articles triés par leur score de qualité.
3. Fournir les nouvelles: les articles les plus marquants sont formatés dans un e-mail bien readable et envoyés à l'utilisateur.

Maintenant, nous pouvons commencer à définir les fonctions.

Obtenir des nouvelles

Importez les bibliothèques nécessaires et chargez le fichier .env

 Importer un système d'exploitation 
Importer JSON
Importer des pandas en tant que PD
à partir de Datetime Import Datetime, Timedelta
à partir de l'image d'importation ipython.display, afficher
de la liste d'importation, littéral, facultatif, typeddict, annoté
De Langchain_Core.Tools Import Tool
De Langchain_Openai Import Chatopenai

à partir de Dotenv Import Load_Dotenv

load_dotenv ('/. env')

# Alternative au fichier .env, nous pouvons également utiliser le fichier .txt comme suit
avec open ('mykey.txt', 'r') comme fichier:
    openai_key = file.read ()
    
os.environ ['openai_api_key'] = openai_key

Lancer le news_api à partir de la clé de newsapiclient et d'API

 de newsapi import newsapiclient

News_api_key = os.environ ['news_api_key']

news_api = newsapiclient (api_key = news_api_key)

Maintenant, définissons l'outil Langchain à l'aide du décorateur «Tool» de Langchain

 @outil
def get_news (requête: str, pass_days: int, domaines: str):
    "" "
    Obtenez des nouvelles sur les paramètres donnés comme la requête, le pass_days, etc.
    Args:
        Requête: recherchez des nouvelles sur ce sujet
        Past_days: Pendant combien de jours dans le passé devrions-nous rechercher?
        Domaines: Recherchez les nouvelles dans ces ressources
    "" "
    Aujourd'hui = datetime.today ()
    From_Date = Today - Timedelta (Days = Past_days)
    news_details = news_api.get_everything (q = query, from_param = from_date, domains = domaines,
                                           sort_by = 'pertinence')
    retourner news_details

L'agent peut également trier les articles en fonction de la pertinence. Voici un exemple de la façon dont la sortie de cette fonction ressemble:

Le décorateur de «@tool» est utilisé pour définir l'outil Langchain. Ensuite, nous pouvons lier cet outil au LLM. Dans la fonction ci-dessus, la chaîne DOC est également importante. C'est ce qui est transmis à la LLM en tant qu'invite pour avoir ces arguments dans la sortie du LLM d'appel à outils.

 # Initialiser le LLM
gpt = chatopenai (modèle = "gpt-4o-mini", température = 0)

# Nous pouvons lier l'outil au LLM afin que le LLM puisse renvoyer l'outil en fonction de la requête.
gpt_with_tools = gpt.bind_tools ([get_news])

Marquer des nouvelles

La fonction SCORE_NEWS traite les articles d'actualité en les marquant en fonction des critères prédéfinis. Ensuite, la fonction renvoie une liste triée des articles de la plus haute qualité.

Importer les méthodes requises

 de Langchain_core.pydantic_v1 Importer BasEmodel, champ
de Langchain_core.prompts Importer ChatPromptTemplate, PromptTemplate
de Langchain_core.Messages Importer HumanMessage

Définissons la fonction

 Def score_news (news_details: dict):
    "" "
    Calculez le score pour News_articles et triez-les par le score.
        news_details: tous les articles de presse    
    
    "" "
    # Accédez au dernier message de l'État pour les articles.
    # La transmission de tous les articles au LLM augmentera le coût. 
    # Nous pouvons choisir de marquer uniquement quelques articles.
    json_articles = json.loads (news_details ['messages'] [- 1] .Content) ['articles']
    Si Len (json_articles)> 15:
        Articles = JSON_ARTICles [: 15]
    autre:
        Articles = JSON_ARTICles
    
    # Invite du système pour guider le LLM pour marquer les articles.
    system_prompt = "" "
    Vous êtes un évaluateur de la qualité des nouvelles.
    Je vous fournirai un article de presse, avec un titre, une description et un contenu tronqué et d'autres détails. 
    Analyser et marquer l'article de presse basé sur les critères suivants:

    Clarity: comment l'article transmet le message de manière concise et compréhensible.
        Échelle: 1 (peu claire) à 25 (très claire)

    Crédibilité: Sur la base de la description et d'autres détails fournis, quelle est la probabilité que l'article soit crédible et factuellement exact?
        Échelle: 1 (non crédible) à 25 (très crédible)

    Potentiel d'engagement: quelle est la probabilité que l'article puisse capter l'attention du lecteur ou provoquer une réflexion supplémentaire.
        Échelle: 1 (pas engageant) à 25 (très engageant)

    Impact: Quelle est l'importance ou l'influence de l'article en termes de conséquences potentielles sociétales, technologiques ou politiques.
        Échelle: 1 (impact minimal) à 25 (impact élevé)

    Fournir le score total sur 100 pour l'article de presse, ajoutant les scores pour chacun des critères ci-dessus.

    Vous évaluerez beaucoup d'articles de presse. Alors, marquez-les tels que nous pouvons tous les trier plus tard.

    "" "
    prompt_template = chatPromptTemplate.from_Messages ([("System", System_Prompt), ("humain", "{news}")]))

    
    # Définissez la classe Pyndantique pour obtenir la sortie dans un format structuré.
   
    NOUVELLES DE CLASSE (BASEMODEL):
        "" "Système de notation des nouvelles" ""
    
        total_score: int = field (description = 'score total pour l'article de presse')
        
        Source: str = champ (Description = "La source des nouvelles")
        Auteur: Field [str] = facultatif (par défaut = aucun, description = "L'auteur des nouvelles")
        
        Titre: str = champ (Description = "Le titre des nouvelles")
        Description: str = champ (Description = "La description des nouvelles")
        
        URL: str = champ (Description = "L'URL des nouvelles")
        Urltoimage: Field [str] = facultatif (par défaut = aucun, description = "L'URL de l'image des nouvelles")

    # GPT 4O fonctionne mieux pour marquer mais plus coûteux.
    gpt_4o = chatopenai (modèle = 'gpt-4o', température = 0)
    Structured_gpt = gpt_4o.with_structured_output (News)
    chaîne = prompt_template | Structured_gpt
    
    # Envoyez chaque article au LLM pour obtenir le score avec les autres détails.
    résultats = [chain.invoke ({'news': article}). dict () pour l'article dans des articles]

    # Triez les articles par partition totale.
    df = pd.dataframe (résultats) .sort_values ​​(par = 'total_score', ascendant = false)
    
    return {"messages": [HumanMessage (contenu = df.to_dict (orient = 'enregistrements'))]}

La fonction prend l'état comme entrée avec le nom comme News_Details. Étant donné que l'État a tous les messages, nous pouvons accéder au dernier message pour les articles. Nous pouvons choisir de marquer uniquement quelques articles par le haut pour économiser les coûts. Nous pouvons essayer différentes invites système pour obtenir le meilleur système de notation.

Il est plus facile de traiter les données si la sortie est dans un format défini. Ainsi, nous pouvons utiliser LLM avec une sortie structurée, où la structure est définie à l'aide de la classe pyndante.

Ensuite, nous pouvons marquer chaque article et les stocker dans un dataframe. Une fois que nous trierons les articles en utilisant le score total et les ajoutez comme message à l'État.

Explication

1. Entrée

La fonction reçoit l'objet d'état en entrée, qui contient tous les messages. Le dernier message de cet État détient les articles de presse. Pour minimiser les coûts, au lieu de marquer tous les articles, nous pouvons limiter le nombre d'articles.

2. Processus de notation

Nous fournissons une invite de système détaillée au LLM, en lui demandant de marquer chaque article en fonction des critères donnés dans l'invite du système.

Le LLM évalue chaque article en fonction des critères définis dans l'invite du système et attribue un score total sur 100, ajoutant des scores de chaque critère.

3. Sortie structurée

Pour nous assurer que la sortie est structurée et facile à traiter, nous définissons un modèle pydatique (actualités). Ce modèle comprend des champs comme `Total_score`,« Title »,« Description »et« URL ». En utilisant ce format structuré, le LLM peut retourner des résultats cohérents et bien organisés.

4. Intégration LLM

Nous utilisons GPT-4O, connu pour sa précision dans les tâches structurées, pour marquer les articles. On constate que GPT-4O est meilleur que GPT-4O-MINI pour évaluer les articles. Chaque article est passé par le LLM, et les résultats sont convertis en format de dictionnaire en utilisant pyndantique.

5. Tri et sortie

Après avoir marqué tous les articles, nous les stockons dans un Pandas DataFrame, trier par leur `Total_score` par ordre décroissant. Ensuite, nous pouvons retourner la liste triée en tant que message à l'état, prêt à être utilisé dans la partie suivante du workflow.

Envoyer un e-mail

La fonction Send_email prend une liste d'articles de presse triés, génère un e-mail HTML et l'envoie au destinataire.

Importer les bibliothèques

 importer smtplib, ssl
Importer la base64
Importer un e-mail

Définissez la fonction Send_email

 def send_email (trid_news):
 
    # Obtenez les nouvelles triées du dernier message de l'État.
    articles = trid_news ['messages'] [- 1] .Content
    
    # Si le News_article a une image, nous pouvons l'afficher dans l'e-mail.
    news_items_html = ""
    Pour un article dans des articles [: 10]:
        Si l'article [«urltoimage»] n'est pas aucun:
            news_items_html = f "" "
            <div>
                <img src="/static/imghwm/default1.png" data-src="https://img.php.cn/upload/article/000/000/000/174442792064130.jpg?x-oss-process=image/resize,p_40" class="lazy" alt="{article ['title']}">
                <div>
                    <h3 id="a-href-Barticle-B-url-D-D-article-title-a"> <a href="%7Barticle%20%5B'url'%5D%7D"> {article ['title']} </a> </h3>
                    <p> {Article ['Description']} </p>
                </div>
            </div>
            "" "
        autre:
            news_items_html = f "" "
            <div>
                <div>
                    <h3 id="a-href-Barticle-B-url-D-D-article-title-a"> <a href="%7Barticle%20%5B'url'%5D%7D"> {article ['title']} </a> </h3>
                    <p> {Article ['Description']} </p>
                </div>
            </div>
            "" "
            
    # CSS pour styliser le message HTML. Nous ajoutons ici le «news_items_html» ci-dessus.
    html = f "" "
        
        <adal>
            <style>
                corps {{
                    Font-Family: Arial, Sans-Serif;
                    Color d&#39;arrière-plan: # C4C4C4;
                    marge: 0;
                    rembourrage: 0;
                }}
                .Container {{
                    Largeur: 80%;
                    largeur maximale: 600px;
                    marge: 0 auto;
                    Color d&#39;arrière-plan: #FFFFFF;
                    rembourrage: 20px;
                    Box-Shadow: 0 4px 8px RGBA (0, 0, 0, 0,1);
                }}
                H1 {{
                    Texte-aligne: Centre;
                    Couleur: # 333;
                }}
                .news-item {{
                    Affichage: flex;
                    Align-Items: Centre;
                    justifier-contenu: espace-intermédiaire;
                    Border-Bottom: 1px solide #eeeeee;
                    rembourrage: 15px 0;
                }}
                .news-item h3 {{
                    marge: 0;
                    taille de police: 16px;
                    Couleur: # 007BFF;
                    marge-gauche: 5px;
                }}
                .news-item p {{
                    taille de police: 14px;
                    Couleur: # 666666;
                    marge: 5px 0;
                    marge-gauche: 5px;
                }}
                .news-item a {{
                    Couleur: # 007BFF;
                    Décoration du texte: aucune;
                }}
                .news-item img {{
                    Largeur: 100px;
                    hauteur: 100px;
                    FIT d&#39;objet: couverture;
                    Border-Radius: 8px;
                }}
                .footer {{
                    marge: 20px;
                    Texte-aligne: Centre;
                    taille de police: 12px;
                    Couleur: # 999999;
                }}
            </ style>
        </ head>
        <body>
            <div>
                <h1> Associé News 
                {news_items_html}
                <div>
                    <p> c&#39;est votre newsletter personnalisée. 
                
            
        
        
    "" "
    
    port = 465 # pour SSL

    Sender_email = "[Email Protected]"
    mot de passe = os.environ [&#39;gmail_password&#39;]
    
    context = ssl.create_default_context ()
 
    # Ajouter le contenu de l&#39;e-mail
    mail = email.message.emailMessage ()
    mail [&#39;to&#39;] = "[e-mail protégé]"
    mail [&#39;from&#39;] = "[e-mail protégé]"
    mail [&#39;sujet&#39;] = "News Digest"
    mail.set_content (html, sous-type = &#39;html&#39;)

    
    avec smtplib.smtp_ssl ("smtp.gmail.com", port, contexte = contexte) comme serveur:
        server.login (Sender_email, mot de passe)
        server.send_message (courrier)</style></adal>

Explication

1. Extraire les nouvelles triées

La fonction commence par accéder aux articles de presse triés du dernier message de l'État. Nous limitons le nombre d'articles affichés dans l'e-mail au top 10.

2. Générer du contenu HTML

La fonction construit dynamiquement le HTML pour chaque article de presse. Si un article comprend une image («urltoimage»), l'image est intégrée dans l'e-mail à côté du titre, du lien et de la description de l'article. Sinon, seul le titre et la description sont affichés. Ce bloc HTML (`news_items_html`) est généré à l'aide d'une boucle qui traite chaque article.

3. Style HTML et CSS

L'e-mail HTML est conçu à l'aide de CSS intégrés pour assurer une disposition visuellement attrayante. La couverture des styles:

• Récipient: Le contenu de l'e-mail principal est enveloppé dans un récipient centré avec un fond blanc et une ombre subtile.
• Articles de nouvelles: Chaque article de presse s'affiche avec son titre (en tant que lien cliquable), la description et éventuellement une image. La mise en page utilise Flexbox pour aligner l'image et le texte côte à côte, avec une bordure séparant chaque article.

4. Composant l'e-mail

L'e-mail est configuré à l'aide de la classe `email.sessage.emailMessage` de Python. Le contenu HTML, la ligne d'objet («News Digest»), l'expéditeur et le destinataire sont spécifiés. Le HTML est inclus comme le contenu principal en utilisant `mail.set_content (html, sous-type = 'html')`.

5. Envoi de l'e-mail

La fonction utilise le serveur SMTP de Gmail pour envoyer l'e-mail en toute sécurité via SSL (port 465). Les informations d'identification Gmail de l'expéditeur sont récupérées à partir de la variable d'environnement `gmail_password` pour éviter les informations sensibles à codage en dur. Après être connecté au serveur SMTP, l'e-mail est envoyé au destinataire.

Construire l'agent

Créons l'agent en fonction des outils et fonctions définis ci-dessus.

Étape 1. Définition des fonctions pour appeler les modèles et les outils.

 à partir de LangGraph.Prebuilt Import ToolNode
De Langgraph.graph Import Stategraph, MessageSsTate, Start, End

# Fonction pour appeler le modèle qui renvoie l'outil en fonction de la requête.
def call_model (état: messageSState):
    messages = état ["messages"]
    réponse = gpt_with_tools.invoke (messages)
    return {"messages": [réponse]}
    
# Si le dernier message de la LLM ci-dessus est TOLL_CALLS, nous retournons "Outils"
def call_tools (état: messageSState) -> littéral ["outils", fin]:
    messages = état ["messages"]
    Last_Message = Messages [-1]
    Si Last_Message.Tool_Calls:
        retourner "outils"
    retour

Étape 2. Construire le graphique du flux de travail. Nous pouvons maintenant utiliser toutes les fonctions définies pour construire l'agent.

 #Create un nœud d'outil avec fonction afin que nous puissions l'utiliser dans le graphique. 
get_news_tool = toolnode ([get_news])


workflow = stategraph (messagessettate)

# Nous commençons l'agent à partir de la fonction call_model.
workflow.add_node ("llm", call_model)
workflow.add_edge (start, "llm")

# Ajoutez le get_news_tool, qui est appelé à partir du LLM ci-dessus en fonction de la requête.
workflow.add_node ("outils", get_news_tool)
workflow.add_conditional_edges ("llm", call_tools)

# Ensuite, nous nous connectons à la fonction SCORE_NEWS de la fonction GET_NEWS
workflow.add_node ("score", score_news)
workflow.add_edge ("outils", "score")

# Ensuite, nous nous connectons à la fonction Send_email de la fonction SCORE_NEWS
workflow.add_node ("mail", send_email)
workflow.add_edge ("score", "mail")

# Nous pouvons terminer avec l'agent après avoir envoyé le courrier
workflow.add_edge ("mail", fin)

Étape 3. Compilation du graphique.

 agent = workflow.Compile ()
affichage (image (agent.get_graph (). Draw_mermaid_png ()))

Maintenant, nous pouvons appeler l'agent avec une requête.

Utilisons une requête qui a moins de nouvelles pour imprimer les sorties à chaque étape de l'agent.

 Query = "Quelles sont les nouvelles de l'équipe indienne de cricket au cours du dernier mois?"

# Cette requête ira le nœud de démarrage.
entrées = {"messages": [("utilisateur", requête)]}

async pour chunk dans agent.astream (entrées, stream_mode = "valeurs"):
    Chunk ["Messages"] [- 1] .pretty_print ()

La sortie sera dans le format illustré ci-dessous. Si aucun article n'est retourné, nous pouvons changer la requête.

Comme nous pouvons le voir, nous commençons par la requête. Le LLM appellera ensuite l'outil «get_news». Ensuite, l'outil renvoie tous les articles. La fonction 'score_news' les traitera ensuite et sortira une liste d'articles avec des scores. Ensuite, la fonction 'Send_email' envoie l'e-mail, bien qu'il n'y ait pas de sortie dans l'état.

De cette façon, nous pouvons interroger l'agent sur n'importe quel sujet et recevoir un e-mail avec des nouvelles organisées.

Conclusion

La construction d'un agent de newsletter utilisant Langgraph et LLMS offre un moyen puissant d'automatiser la conservation des nouvelles et la livraison. En combinant des données en temps réel, une notation intelligente et une livraison de messagerie personnalisée, cette approche rationalise la création de newsletters personnalisées, l'amélioration de l'engagement des lecteurs et la pertinence du contenu sans effort.

Questions fréquemment posées

Q1. Qu'est-ce que Langgraph et comment ça marche?

A. Langgraph est un cadre pour construire des workflows dynamiques qui intègrent des modèles de grandes langues (LLM) avec une logique personnalisée. Il permet aux développeurs de définir les flux de travail comme des graphiques utilisant des états, des nœuds et des bords, où chaque nœud représente une fonction ou une tâche, et les bords définissent le flux de données entre ces tâches.

Q2. Quelles sont les principales composantes de Langgraph?

A. Langgraph se compose de trois composants principaux: État, qui maintient les données partagées sur l'application; Les nœuds, qui représentent des fonctions individuelles qui lisent ou modifient l'état; et les bords, qui définissent le flux de données entre les nœuds. Les bords conditionnels permettent des flux de travail flexibles basés sur la décision.

Q3. Langgraph peut-il intégrer des API et des outils externes?

A. Oui, Langgraph peut intégrer des API et des outils externes. Vous pouvez définir des nœuds pour gérer des tâches spécifiques, telles que passer des appels API ou interagir avec des services tiers, puis utiliser ces nœuds dans le flux de travail pour créer des applications dynamiques en temps réel.

Q4. Comment Langgraph gère-t-il les flux de travail conditionnels?

A. Langgraph vous permet de définir les bords conditionnels, qui utilisent une fonction pour déterminer l'étape suivante du flux de travail. Cette fonction facilite la gestion des scénarios complexes basés sur des décisions où le flux dépend de conditions spécifiques ou d'entrée utilisateur.

Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!