LangGraph ReAct-Funktionsaufruf – Analytics Vidhya

Das LangGraph ReAct Perform-Calling Sample bietet ein leistungsstarkes Framework für die Integration verschiedener Instruments wie Suchmaschinen, Rechner und APIs mit einem intelligenten Sprachmodell, um ein interaktiveres und reaktionsfähigeres System zu schaffen. Dieses Muster basiert auf dem Reasoning + Performing (ReAct)-Ansatz, der es einem Sprachmodell ermöglicht, nicht nur durch Abfragen zu argumentieren, sondern auch bestimmte Aktionen auszuführen, wie z. B. den Aufruf externer Instruments, um Daten abzurufen oder Berechnungen durchzuführen.

Lernziel

• Verstehen Sie den ReAct-Ansatz: Die Lernenden können den Reasoning + Performing (ReAct)-Ansatz und seine Bedeutung für die Verbesserung der Fähigkeiten von Sprachmodellen erklären.
• Implementieren Sie die Instrument-Integration: Die Teilnehmer erwerben die Fähigkeit, verschiedene externe Instruments (z. B. APIs, Rechner) in Sprachmodelle zu integrieren und so dynamische und interaktive Antworten auf Benutzeranfragen zu ermöglichen.
• Entwickeln Sie diagrammbasierte Arbeitsabläufe: Die Lernenden werden in der Lage sein, diagrammbasierte Arbeitsabläufe zu erstellen und zu verwalten, die Benutzerinteraktionen effektiv zwischen Argumentation und Werkzeugaufruf weiterleiten.
• Erstellen Sie benutzerdefinierte Instruments: Die Teilnehmer lernen, wie sie benutzerdefinierte Instruments definieren und integrieren, um die Funktionalität von Sprachmodellen zu erweitern und so maßgeschneiderte Lösungen für spezifische Benutzeranforderungen zu ermöglichen.
• Bewerten Sie die Benutzererfahrung: Die Lernenden werden die Auswirkungen des LangGraph ReAct-Funktionsaufrufmusters auf die Benutzererfahrung bewerten und verstehen, wie der Datenabruf in Echtzeit und intelligentes Denken das Engagement und die Zufriedenheit steigern.

Dieser Artikel wurde im Rahmen der veröffentlicht Knowledge Science-Blogathon.

Was ist ReAct Immediate?

Die herkömmliche ReAct-Eingabeaufforderung für den Assistenten richtet das folgende Framework ein:

• Fähigkeiten des Assistenten: Der Assistent wird als leistungsstarkes, sich weiterentwickelndes Sprachmodell vorgestellt, das verschiedene Aufgaben bewältigen kann. Der Schlüsselfaktor dabei ist seine Fähigkeit, menschenähnliche Antworten zu generieren, sich an sinnvollen Diskussionen zu beteiligen und Erkenntnisse auf der Grundlage großer Textmengen zu liefern.
• Zugriff auf Instruments: Der Assistent erhält Zugriff auf verschiedene Instruments wie:
  • Wikipedia-Suche: Wird zum Abrufen von Daten aus Wikipedia verwendet.
  • Websuche: Dies dient zur Durchführung allgemeiner On-line-Suchen.
  • Rechner: Zur Durchführung arithmetischer Operationen.
  • Wetter-API: Zum Abrufen von Wetterdaten.
  • Diese Instruments ermöglichen es dem Assistenten, seine Fähigkeiten über die Textgenerierung hinaus auf das Abrufen von Daten in Echtzeit und das Lösen mathematischer Probleme zu erweitern.

Das ReAct-Muster verwendet ein strukturiertes Format für die Interaktion mit Instruments, um Klarheit und Effizienz zu gewährleisten. Wenn der Assistent feststellt, dass er ein Werkzeug verwenden muss, folgt er diesem Muster:

Thought: Do I would like to make use of a instrument? Sure
Motion: (instrument identify)
Motion Enter: (enter to the instrument)
Remark: (end result from the instrument)

Wenn der Benutzer beispielsweise fragt: „Wie ist das Wetter in London?“, könnte der Denkprozess des Assistenten wie folgt aussehen:

Thought: Do I would like to make use of a instrument? Sure
Motion: weather_api
Motion Enter: London
Remark: 15°C, cloudy

Sobald das Instrument das Ergebnis liefert, antwortet der Assistent mit einer abschließenden Antwort:

Last Reply: The climate in London is 15°C and cloudy.

Implementierung des LangGraph ReAct-Funktionsaufrufmusters

Bauen wir auf der Umsetzung auf LangGraph ReAct Funktionsaufrufmuster durch Integration des Reasoner-Knotens und Aufbau eines Workflows, der es unserem Assistenten ermöglicht, effektiv mit den von uns definierten Instruments zu interagieren.

Umgebungseinrichtung

Zuerst richten wir die Umgebung für die Verwendung des OpenAI-Modells ein, indem wir die erforderlichen Bibliotheken importieren und das Modell mit einem API-Schlüssel initialisieren:

import os
from google.colab import userdata
# Setting the OpenAI API key
os.environ('OPENAI_API_KEY') = userdata.get('OPENAI_API_KEY')

from langchain_openai import ChatOpenAI
#Initializing the language mannequin
llm = ChatOpenAI(mannequin="gpt-4o")

Werkzeugdefinitionen

Als nächstes definieren wir die Rechenwerkzeuge, die der Assistent verwenden kann:

def multiply(a: int, b: int) -> int:
    """Multiply a and b.
    Args:
        a: first int
        b: second int
    """
    return a * b
# This might be a instrument
def add(a: int, b: int) -> int:
    """Provides a and b.
    Args:
        a: first int
        b: second int
    """
    return a + b

def divide(a: int, b: int) -> float:
    """Divide a and b.
    Args:
        a: first int
        b: second int
    """
    return a / b

Zusätzlich zu diesen Rechenfunktionen integrieren wir eine Suchfunktion, die es dem Assistenten ermöglicht, Informationen aus dem Internet abzurufen:

# search instruments
from langchain_community.instruments import DuckDuckGoSearchRun
search = DuckDuckGoSearchRun()
# Instance search question to get Brad Pitt's age
search.invoke("How outdated is Brad Pitt?")

Ausgabe:

Brad Pitt. Picture: Amy Sussman/Getty Photos. Brad Pitt is opening up about
rising older. 
The Oscar winner, 60, and George Clooney, 63, spoke with GQ in an interview
revealed on
Tuesday, August 13 ... Brad Pitt marked his sixtieth birthday with a celebration
at Mom Wolf
in Los Angeles this week. One onlooker says the actor 'regarded tremendous joyful' at
the occasion, 
and 'everybody had a smile on their faces.' Brad Pitt is an American actor
born on December 18, 
1963, in Shawnee, Oklahoma. He has starred in varied movies, received an Academy
Award, and married 
Angelina Jolie. Brad Pitt rang in his six-decade milestone in a giant approach —
twice! Pitt celebrated 
his sixtieth birthday on Monday, together with mates and his girlfriend, Ines de
Ramon, 33, 
with "low key ... Brad Pitt's internet price is estimated to be round $400
million. 
His performing profession alone has contributed considerably to this, with Pitt
commanding as a lot as $20 million
per movie. ... Born on December 18, 1963, Brad Pitt is 61 years outdated. His
zodiac signal is Sagittarius 
who're identified for being adventurous, impartial, and passionate—traits ...

Bindungstools an das LLM

Anschließend binden wir die definierten Instruments an das Sprachmodell:

instruments = (add, multiply, divide, search)

llm_with_tools = llm.bind_tools(instruments)

Den Reasoner definieren

Der nächste Schritt ist die Implementierung der Reasoner-Funktion, die als Entscheidungsknoten des Assistenten dient. Diese Funktion verwendet die gebundenen Instruments, um Benutzereingaben zu verarbeiten:

from langgraph.graph import MessagesState
from langchain_core.messages import HumanMessage, SystemMessage


# System message
sys_msg = SystemMessage(content material="You're a useful assistant tasked with utilizing search and performing arithmetic on a set of inputs.")

Knotenimplementierung

def reasoner(state: MessagesState):
   return {"messages": (llm_with_tools.invoke((sys_msg) + state("messages")))}

Erstellen des Graph-Workflows

Nachdem wir nun unsere Instruments und den Reasoner definiert haben, können wir den Diagramm-Workflow erstellen, der zwischen Reasoning und Instrument-Aufruf weiterleitet:

from langgraph.graph import START, StateGraph
from langgraph.prebuilt import tools_condition # that is the checker for the when you bought a instrument again
from langgraph.prebuilt import ToolNode
from IPython.show import Picture, show

# Graph
builder = StateGraph(MessagesState)

# Add nodes
builder.add_node("reasoner", reasoner)
builder.add_node("instruments", ToolNode(instruments)) # for the instruments

# Add edges
builder.add_edge(START, "reasoner")
builder.add_conditional_edges(
    "reasoner",
    # If the newest message (end result) from node reasoner is a instrument name -> tools_condition routes to instruments
    # If the newest message (end result) from node reasoner is a not a instrument name -> tools_condition routes to END
    tools_condition,
)
builder.add_edge("instruments", "reasoner")
react_graph = builder.compile()

# Show the graph
show(Picture(react_graph.get_graph(xray=True).draw_mermaid_png()))

Verwenden des Workflows

Wir können jetzt Abfragen bearbeiten und den Assistenten mit dem erstellten Diagramm verwenden. Wenn ein Benutzer beispielsweise fragt: „Wie alt ist Brad Pitt doppelt so alt?“ Das System sucht zunächst mit der Suchfunktion DuckDuckGo nach Brad Pitts Alter und multipliziert dieses Ergebnis dann mit 2.

So rufen Sie das Diagramm für eine Benutzerabfrage auf:

Beispielabfrage: Wie alt ist Brad Pitt doppelt so alt?

messages = (HumanMessage(content material="What's 2 instances Brad Pitt's age?"))
messages = react_graph.invoke({"messages": messages})
#Displaying the response
for m in messages('messages'):
    m.pretty_print()

Um die Fähigkeiten unseres Assistenten zu erweitern, werden wir ein benutzerdefiniertes Instrument hinzufügen, das Aktienkurse mithilfe der Yahoo Finance-Bibliothek abruft. Dadurch kann der Assistent finanzbezogene Fragen effektiv beantworten.

Schritt 1: Installieren Sie das Yahoo Finance-Paket

Bevor wir beginnen, stellen Sie sicher, dass die yfinance-Bibliothek installiert ist. Diese Bibliothek wird uns den Zugriff auf Börsendaten ermöglichen.

!pip -q set up yahoo-finance

Schritt 2: Erforderliche Bibliotheken importieren

Als nächstes importieren wir die notwendige Bibliothek für die Interaktion mit Yahoo Finance und definieren die Funktion, die den Aktienkurs basierend auf dem Tickersymbol abruft:

import yfinance as yf

def get_stock_price(ticker: str) -> float:
    """Will get a inventory worth from Yahoo Finance.

    Args:
        ticker: ticker str
    """
    # """It is a instrument for getting the worth of a inventory when handed a ticker image"""
    inventory = yf.Ticker(ticker)
    return inventory.data('previousClose')

Schritt 3: Testen Sie das benutzerdefinierte Instrument

Um zu überprüfen, ob unser Instrument ordnungsgemäß funktioniert, können wir einen Testanruf durchführen, um den Aktienkurs eines bestimmten Unternehmens abzurufen. Lassen Sie uns zum Beispiel den Preis für Apple Inc. (AAPL) ermitteln:

get_stock_price("AAPL")

Ausgabe

222.5

Schritt 4: Definieren Sie die Reasoner-Funktion

Als nächstes müssen wir die Reasoner-Funktion ändern, um bestandsbezogene Abfragen zu ermöglichen. Die Funktion prüft die Artwork der Abfrage und bestimmt, ob das Aktienkurs-Instrument verwendet werden soll:

from langchain_core.messages import HumanMessage, SystemMessage
def reasoner(state):
    question = state("question")
    messages = state("messages")
    # System message indicating the assistant's capabilities
    sys_msg = SystemMessage(content material="You're a useful assistant tasked with utilizing search, the yahoo finance instrument and performing arithmetic on a set of inputs.")
    message = HumanMessage(content material=question)
    messages.append(message)
    # Invoke the LLM with the messages
    end result = (llm_with_tools.invoke((sys_msg) + messages))
    return {"messages":end result}

Schritt 5: Aktualisieren Sie die Instruments-Liste

Jetzt müssen wir die neu erstellte Aktienkursfunktion zu unserer Werkzeugliste hinzufügen. Dadurch wird sichergestellt, dass unser Assistent bei Bedarf auf dieses Instrument zugreifen kann:

# Replace the instruments record to incorporate the inventory worth perform
instruments = (add, multiply, divide, search, get_stock_price)
# Re-initialize the language mannequin with the up to date instruments
llm = ChatOpenAI(mannequin="gpt-4o")
llm_with_tools = llm.bind_tools(instruments)


instruments(4)

Wir werden die Fähigkeiten unseres Assistenten weiter verbessern Implementierung eines diagrammbasierten Workflows zur Verwaltung von Abfragen im Zusammenhang mit Arithmetik und Aktienkursen. In diesem Abschnitt geht es darum, den Standing für unseren Workflow zu definieren, Knoten einzurichten und verschiedene Abfragen auszuführen.

Schritt 1: Definieren Sie den Diagrammstatus

Wir beginnen damit, den Zustand für unser Diagramm mithilfe eines TypedDict zu definieren. Dies ermöglicht uns die Verwaltung und Typprüfung der verschiedenen Elemente unseres Standing, einschließlich der Abfrage, der Finanzdaten, der endgültigen Antwort und des Nachrichtenverlaufs.

from typing import Annotated, TypedDict
import operator
from langchain_core.messages import AnyMessage
from langgraph.graph.message import add_messages
class GraphState(TypedDict):
    """State of the graph."""
    question: str
    finance: str
    final_answer: str
    # intermediate_steps: Annotated(record(tuple(AgentAction, str)), operator.add)
    messages: Annotated(record(AnyMessage), operator.add)

Schritt 2: Erstellen Sie das Zustandsdiagramm

Als Nächstes erstellen wir eine Instanz der StateGraph-Klasse. Dieses Diagramm verwaltet die verschiedenen Knoten und Übergänge basierend auf dem Standing der Konversation:

from langgraph.graph import START, StateGraph
from langgraph.prebuilt import tools_condition # that is the checker for the
from langgraph.prebuilt import ToolNode
# Graph
workflow = StateGraph(GraphState)
# Add Nodes
workflow.add_node("reasoner", reasoner)
workflow.add_node("instruments", ToolNode(instruments)) 

Schritt 3: Kanten zum Diagramm hinzufügen

Wir definieren, wie die Knoten miteinander interagieren, indem wir Kanten zum Diagramm hinzufügen. Insbesondere möchten wir sicherstellen, dass der Argumentationsknoten, nachdem er die Eingabe verarbeitet hat, je nach Ergebnis entweder ein Instrument aufruft oder den Workflow beendet:

# Add Nodes
workflow.add_node("reasoner", reasoner)
workflow.add_node("instruments", ToolNode(instruments)) # for the instruments
# Add Edges
workflow.add_edge(START, "reasoner")
workflow.add_conditional_edges(
    "reasoner",
    # If the newest message (end result) from node reasoner is a instrument name -> tools_condition routes to instruments
    # If the newest message (end result) from node reasoner is a not a instrument name -> tools_condition routes to END
    tools_condition,
)
workflow.add_edge("instruments", "reasoner")
react_graph = workflow.compile()

Schritt 4: Visualisieren Sie das Diagramm

Wir können das erstellte Diagramm visualisieren, um zu verstehen, wie unser Arbeitsablauf strukturiert ist. Dies ist nützlich zum Debuggen und Sicherstellen, dass die Logik wie vorgesehen abläuft:

# Present
show(Picture(react_graph.get_graph(xray=True).draw_mermaid_png()))

Schritt 5: Abfragen ausführen

Nachdem unser Workflow nun eingerichtet ist, können wir verschiedene Abfragen ausführen, um seine Funktionalität zu testen. Wir werden verschiedene Arten von Fragen bereitstellen, um zu sehen, wie intestine der Assistent antworten kann.

Frage 1: Wie alt ist Brad Pitt doppelt so alt?

response = react_graph.invoke({"question": "What's 2 instances Brad Pitt's age?", "messages": ()})
response('messages')(-1).pretty_print()

response = react_graph.invoke({"question": "What's the inventory worth of Apple?", "messages": ()})
for m in response('messages'):
    m.pretty_print()

Frage 2: Wie hoch ist der Aktienkurs von Apple?

response = react_graph.invoke({"question": "What's the inventory worth of the corporate that Jensen Huang is CEO of?", "messages": ()})
for m in response('messages'):
    m.pretty_print()

Frage 3: Wie hoch wird der Preis der Nvidia-Aktie sein, wenn sie sich verdoppelt?

response = react_graph.invoke({"question": "What would be the worth of nvidia inventory if it doubles?", "messages": ()})
for m in response('messages'):
    m.pretty_print()

show(Picture(react_graph.get_graph(xray=True).draw_mermaid_png()))

Abschluss

Das LangGraph ReAct Perform-Calling Sample bietet ein leistungsstarkes Framework für die Integration von Instruments in Sprachmodelle und verbessert deren Interaktivität und Reaktionsfähigkeit. Durch die Kombination von Argumentation und Aktion kann das Modell Abfragen clever verarbeiten und Aktionen ausführen, beispielsweise das Abrufen von Echtzeitdaten oder das Durchführen von Berechnungen. Der strukturierte Arbeitsablauf ermöglicht eine effiziente Instrument-Nutzung und ermöglicht dem Assistenten die Bearbeitung vielfältiger Anfragen, von arithmetischen Operationen bis hin zur Aktienkursabfrage. Insgesamt verbessert dieses Muster die Fähigkeiten intelligenter Assistenten erheblich und ebnet den Weg für dynamischere Benutzerinteraktionen.

Um die Agent-KI besser zu verstehen, erkunden Sie außerdem Folgendes: Das Agentic AI Pioneer-Programm