LangGraph-Tutorial: Vollständiger Leitfaden für Anfänger zum Einstieg

LangGraph ist ein Python-Framework, das für den Aufbau zustandsbehafteter KI-Workflows mit graphenbasierten Strukturen entwickelt wurde. Im Gegensatz zu linearen Tools LangGraph ermöglicht die dynamische Anpassung von Workflows an Bedingungen, Ergebnisse oder Benutzereingaben. Zu den herausragenden Funktionen gehören persistentes Statusmanagement, Multi-Agent-Koordination und integrierte Unterstützung für menschliche Überwachung. Diese Funktionen machen es ideal für die Erstellung fortschrittlicher Anwendungen wie Chatbots, kollaborative Systeme und bedingte Workflows.

LangGraph vereinfacht komplexe Aufgaben wie die Aufrechterhaltung des Gesprächskontexts oder die Integration externer Tools. Ein mit LangGraph erstellter Chatbot kann beispielsweise den Benutzerverlauf verfolgen, Probleme an menschliche Agenten weiterleiten und Antworten basierend auf dem gespeicherten Kontext generieren. Durch den graphenbasierten Ansatz können Entwickler Workflows entwerfen, die Verzweigungen, Schleifen und Fehlerbehebung effizient handhaben.

Für diejenigen, die eine Low-Code-Alternative suchen, Latenknoten bietet eine Visual-First-Plattform, die viele der Prinzipien von LangGraph integriert und die Workflow-Erstellung auch für Benutzer ohne umfangreiche Programmiererfahrung zugänglich macht. Mit Latenode können Sie Workflows visuell gestalten, Status verwalten und über 200 KI-Modelle nahtlos integrieren. Ob Sie Chatbots erstellen, Genehmigungen automatisieren oder Multi-Agent-Aufgaben koordinieren – Tools wie LangGraph und Latenode bieten praktische, auf Ihre Bedürfnisse zugeschnittene Lösungen.

LangGraph Tutorial 1: Komponenten von LangGraph Erklärt | Zustand | Knoten | Kanten

LangGraph-Tutorial für Anfänger

LangGraph ist ein Python-Framework, das die Workflow-Automatisierung optimieren soll, angefangen bei der Grundeinrichtung bis hin zur Erstellung komplexer, anpassbarer Systeme.

Installation und Einrichtung

Um mit LangGraph zu beginnen, müssen Sie zunächst Ihre Umgebung einrichten. Erstellen Sie zunächst eine dedizierte virtuelle Umgebung, um Abhängigkeiten zu isolieren und Konflikte zu vermeiden. Öffnen Sie Ihr Terminal und führen Sie die folgenden Befehle aus:

python -m venv venv
<span class="hljs-built_in">source</span> venv/bin/activate  <span class="hljs-comment"># For macOS/Linux</span>
<span class="hljs-comment"># venv\Scripts\activate   # For Windows</span>

Sobald die virtuelle Umgebung aktiviert ist, installieren Sie LangGraph über pip:

pip install -U langgraph

Sie können die Installation bestätigen, indem Sie die Bibliothek in ein Python REPL importieren:

<span class="hljs-keyword">import</span> langgraph

LangGraph erfordert häufig zusätzliche Abhängigkeiten für die Integration mit Sprachmodellen oder externen Tools. Zum Beispiel:

• Arbeiten jederzeit weiterbearbeiten können. Jede Präsentation und jeder KI-Avatar, den Sie von Grund auf neu erstellen oder hochladen, langchain-openai für OpenAI Modelle.
• Installieren langchain[anthropic] für Claude Integration.
• Speichern tavily-python für Websuchfunktionen [2].[1].[3].[4]..

Um API-Schlüssel sicher zu verwalten, speichern Sie sie in Umgebungsvariablen. Legen Sie Ihren OpenAI-API-Schlüssel beispielsweise wie folgt fest:

<span class="hljs-built_in">export</span> OPENAI_API_KEY=<span class="hljs-string">"your-api-key-here"</span>

Unter Windows ersetzen export und set. Diese Schlüssel ermöglichen LangGraph die Interaktion mit externen Diensten während der Workflow-Ausführung [2].[1].[3].[4]..

Wenn die Umgebung bereit ist und LangGraph installiert ist, können Sie Ihren ersten Workflow erstellen.

Erstellen Ihres ersten Diagramms

LangGraph-Workflows drehen sich um die Definition und Verwaltung von Zuständen unter Verwendung von Pythons TypedDict für typsichere Datenverarbeitung. Hier ist ein einfaches Beispiel für den Einstieg:

<span class="hljs-keyword">from</span> typing <span class="hljs-keyword">import</span> TypedDict
<span class="hljs-keyword">from</span> langgraph.graph <span class="hljs-keyword">import</span> StateGraph, START, END

<span class="hljs-keyword">class</span> <span class="hljs-title class_">GraphState</span>(<span class="hljs-title class_ inherited__">TypedDict</span>):
    message: <span class="hljs-built_in">str</span>
    count: <span class="hljs-built_in">int</span>

Workflow-Operationen sind in Knoten gekapselt, die den aktuellen Status verarbeiten und Aktualisierungen als Wörterbücher zurückgeben. Jeder Knoten konzentriert sich auf eine bestimmte Aufgabe und behält dabei den Gesamtstatus bei:

<span class="hljs-keyword">def</span> <span class="hljs-title function_">greeting_node</span>(<span class="hljs-params">state: GraphState</span>):
    <span class="hljs-keyword">return</span> {<span class="hljs-string">"message"</span>: <span class="hljs-string">f"Hello! Processing item <span class="hljs-subst">{state[<span class="hljs-string">'count'</span>]}</span>"</span>}

<span class="hljs-keyword">def</span> <span class="hljs-title function_">counter_node</span>(<span class="hljs-params">state: GraphState</span>):
    <span class="hljs-keyword">return</span> {<span class="hljs-string">"count"</span>: state[<span class="hljs-string">"count"</span>] + <span class="hljs-number">1</span>}

Als nächstes initialisieren Sie ein StateGraph, fügen Sie Knoten hinzu und definieren Sie die Ausführungsreihenfolge mithilfe von Kanten:

<span class="hljs-comment"># Initialize the graph with state schema</span>
workflow = StateGraph(GraphState)

<span class="hljs-comment"># Add nodes to the graph</span>
workflow.add_node(<span class="hljs-string">"greeting"</span>, greeting_node)
workflow.add_node(<span class="hljs-string">"counter"</span>, counter_node)

<span class="hljs-comment"># Define execution flow</span>
workflow.add_edge(START, <span class="hljs-string">"greeting"</span>)
workflow.add_edge(<span class="hljs-string">"greeting"</span>, <span class="hljs-string">"counter"</span>)
workflow.add_edge(<span class="hljs-string">"counter"</span>, END)

<span class="hljs-comment"># Compile the graph</span>
app = workflow.<span class="hljs-built_in">compile</span>()

Um das Diagramm auszuführen, geben Sie einen Anfangszustand an und rufen Sie die kompilierte Anwendung auf:

initial_state = {<span class="hljs-string">"message"</span>: <span class="hljs-string">""</span>, <span class="hljs-string">"count"</span>: <span class="hljs-number">0</span>}
result = app.invoke(initial_state)
<span class="hljs-built_in">print</span>(result)  <span class="hljs-comment"># {'message': 'Hello! Processing item 0', 'count': 1}</span>

Dieses Beispiel veranschaulicht die Kernkonzepte von LangGraph. Von hier aus können Sie zu komplexeren Workflows übergehen.

Grundlagen der Zustandsverwaltung

Die Zustandsverwaltung in LangGraph geht über die einfache Datenübertragung hinaus. Sie gewährleistet einen dauerhaften, typisierten Zustand während des gesamten Workflows und ermöglicht so eine nahtlose Koordination zwischen Vorgängen.

Im Gegensatz zu zustandslosen Systemen, die zwischen den Schritten den Kontext verlieren, behält LangGraph den Status über den gesamten Workflow-Lebenszyklus hinweg bei. Diese Funktion ist besonders nützlich für Anwendungen wie Konversations-KI oder mehrstufige Prozesse. So können Sie beispielsweise den Kontext einer Konversation mit einem TypedDict:

<span class="hljs-keyword">class</span> <span class="hljs-title class_">ConversationState</span>(<span class="hljs-title class_ inherited__">TypedDict</span>):
    messages: <span class="hljs-built_in">list</span>
    user_id: <span class="hljs-built_in">str</span>
    context: <span class="hljs-built_in">dict</span>

<span class="hljs-keyword">def</span> <span class="hljs-title function_">add_message_node</span>(<span class="hljs-params">state: ConversationState</span>):
    new_message = {<span class="hljs-string">"role"</span>: <span class="hljs-string">"assistant"</span>, <span class="hljs-string">"content"</span>: <span class="hljs-string">"How can I help?"</span>}
    <span class="hljs-keyword">return</span> {<span class="hljs-string">"messages"</span>: state[<span class="hljs-string">"messages"</span>] + [new_message]}

Wenn ein Knoten den Status aktualisiert, führt LangGraph die Änderungen mit den vorhandenen Daten zusammen. In diesem Beispiel messages Liste wird aktualisiert, während user_id context bleiben unverändert.

Die Statusvalidierung ist in das Framework integriert und verwendet TypedDict-Schemas, um Typabweichungen zur Laufzeit zu erkennen. Dieser Ansatz hilft, Fehler frühzeitig zu erkennen, spart Debugging-Zeit und verbessert die Zuverlässigkeit.

Erweiterte Muster in LangGraph

Sobald Sie mit den Grundlagen vertraut sind, bietet LangGraph erweiterte Muster zur Handhabung komplexer Szenarien wie bedingter Verzweigung, Schleifen, Fehlerbehandlung und Human-in-the-Loop-Workflows.

Bedingte Verzweigung
Sie können dynamische Workflows erstellen, die sich an die jeweiligen Statusbedingungen anpassen. Beispiel:

<span class="hljs-keyword">def</span> <span class="hljs-title function_">should_escalate</span>(<span class="hljs-params">state: ConversationState</span>):
    <span class="hljs-keyword">if</span> state.get(<span class="hljs-string">"confidence_score"</span>, <span class="hljs-number">0</span>) < <span class="hljs-number">0.7</span>:
        <span class="hljs-keyword">return</span> <span class="hljs-string">"human_agent"</span>
    <span class="hljs-keyword">return</span> <span class="hljs-string">"ai_response"</span>

workflow.add_conditional_edges(
    <span class="hljs-string">"analyze_query"</span>,
    should_escalate,
    {<span class="hljs-string">"human_agent"</span>: <span class="hljs-string">"escalate"</span>, <span class="hljs-string">"ai_response"</span>: <span class="hljs-string">"respond"</span>}
)

Zyklische Flüsse
Workflows können für iterative Verarbeitung oder Wiederholungsversuche zu vorherigen Knoten zurückkehren. Dies ist nützlich für Aufgaben, die mehrere Versuche erfordern:

<span class="hljs-keyword">def</span> <span class="hljs-title function_">check_quality</span>(<span class="hljs-params">state: TaskState</span>):
    <span class="hljs-keyword">if</span> state[<span class="hljs-string">"attempts"</span>] < <span class="hljs-number">3</span> <span class="hljs-keyword">and</span> state[<span class="hljs-string">"quality_score"</span>] < <span class="hljs-number">0.8</span>:
        <span class="hljs-keyword">return</span> <span class="hljs-string">"retry"</span>
    <span class="hljs-keyword">return</span> <span class="hljs-string">"complete"</span>

workflow.add_conditional_edges(
    <span class="hljs-string">"quality_check"</span>,
    check_quality,
    {<span class="hljs-string">"retry"</span>: <span class="hljs-string">"process_task"</span>, <span class="hljs-string">"complete"</span>: END}
)

Human-in-the-Loop-Workflows
Integrieren Sie an wichtigen Entscheidungspunkten menschliche Kontrolle. Zum Beispiel:

workflow.add_node(<span class="hljs-string">"human_approval"</span>, human_approval_node)
workflow.add_edge(<span class="hljs-string">"generate_response"</span>, <span class="hljs-string">"human_approval"</span>)
workflow.add_conditional_edges(
    <span class="hljs-string">"human_approval"</span>,
    <span class="hljs-keyword">lambda</span> state: <span class="hljs-string">"approved"</span> <span class="hljs-keyword">if</span> state[<span class="hljs-string">"approved"</span>] <span class="hljs-keyword">else</span> <span class="hljs-string">"rejected"</span>,
    {<span class="hljs-string">"approved"</span>: <span class="hljs-string">"send_response"</span>, <span class="hljs-string">"rejected"</span>: <span class="hljs-string">"revise_response"</span>}
)

Fehlerbehandlung
LangGraph unterstützt eine robuste Fehlerbehandlung mit Try-Catch-Mustern und bedingtem Routing zur Wiederherstellung:

<span class="hljs-keyword">def</span> <span class="hljs-title function_">safe_api_call</span>(<span class="hljs-params">state: APIState</span>):
    <span class="hljs-keyword">try</span>:
        result = external_api.call(state[<span class="hljs-string">"query"</span>])
        <span class="hljs-keyword">return</span> {<span class="hljs-string">"result"</span>: result, <span class="hljs-string">"error"</span>: <span class="hljs-literal">None</span>}
    <span class="hljs-keyword">except</span> Exception <span class="hljs-keyword">as</span> e:
        <span class="hljs-keyword">return</span> {<span class="hljs-string">"result"</span>: <span class="hljs-literal">None</span>, <span class="hljs-string">"error"</span>: <span class="hljs-built_in">str</span>(e)}

Diese fortschrittlichen Techniken ermöglichen die Erstellung anpassbarer, praxisnaher Arbeitsabläufe und verwandeln einfache Prozesse in leistungsstarke Systeme.

LangGraph-Projekte mit Codebeispielen

LangGraph-Projekte erwecken theoretische Konzepte zum Leben, indem sie sie in praktische Geschäftsanwendungen umsetzen. Diese Beispiele bauen auf dem grundlegenden LangGraph-Tutorial auf und zeigen, wie die Muster in realen Szenarien angewendet werden.

Chatbot mit Speicher unterstützen

Ein Support-Chatbot, der den Gesprächsverlauf speichert, kann die Benutzerinteraktion erheblich verbessern. Durch die Kombination der Statusverwaltung von LangGraph mit externen Tools können Sie einen Chatbot erstellen, der den Kontext über mehrere Chats hinweg aufrechterhält und gleichzeitig auf eine simulierte Wissensdatenbank zugreift.

So starten Sie:

1. Definieren Sie die Staatsstruktur

Der Status des Chatbots sollte wichtige Details wie Gesprächsverlauf, Benutzerkontext und Tool-Ausgaben erfassen. Hier ein Beispiel:

<span class="hljs-keyword">from</span> typing <span class="hljs-keyword">import</span> TypedDict, <span class="hljs-type">List</span>, <span class="hljs-type">Optional</span>
<span class="hljs-keyword">from</span> langgraph.graph <span class="hljs-keyword">import</span> StateGraph, START, END
<span class="hljs-keyword">from</span> langchain_openai <span class="hljs-keyword">import</span> ChatOpenAI

<span class="hljs-keyword">class</span> <span class="hljs-title class_">ChatbotState</span>(<span class="hljs-title class_ inherited__">TypedDict</span>):
    messages: <span class="hljs-type">List</span>[<span class="hljs-built_in">dict</span>]
    user_id: <span class="hljs-built_in">str</span>
    conversation_id: <span class="hljs-built_in">str</span>
    knowledge_base_results: <span class="hljs-type">Optional</span>[<span class="hljs-built_in">str</span>]
    escalation_needed: <span class="hljs-built_in">bool</span>
    confidence_score: <span class="hljs-built_in">float</span>

2. Simulieren Sie die Suche in der Wissensdatenbank

Erstellen Sie eine Funktion zum Abrufen relevanter Informationen basierend auf Benutzerabfragen:

<span class="hljs-keyword">def</span> <span class="hljs-title function_">search_knowledge_base</span>(<span class="hljs-params">query: <span class="hljs-built_in">str</span></span>) -> <span class="hljs-built_in">str</span>:
    <span class="hljs-comment"># Simulate a knowledge base search</span>
    knowledge_items = {
        <span class="hljs-string">"password"</span>: <span class="hljs-string">"To reset your password, click 'Forgot Password' on the login page."</span>,
        <span class="hljs-string">"billing"</span>: <span class="hljs-string">"Billing issues can be resolved by contacting our finance team at [email protected]."</span>,
        <span class="hljs-string">"technical"</span>: <span class="hljs-string">"For technical support, please provide your system specifications and error details."</span>
    }

    <span class="hljs-keyword">for</span> key, value <span class="hljs-keyword">in</span> knowledge_items.items():
        <span class="hljs-keyword">if</span> key <span class="hljs-keyword">in</span> query.lower():
            <span class="hljs-keyword">return</span> value
    <span class="hljs-keyword">return</span> <span class="hljs-string">"I couldn't find specific information about your query."</span>

<span class="hljs-keyword">def</span> <span class="hljs-title function_">knowledge_search_node</span>(<span class="hljs-params">state: ChatbotState</span>):
    last_message = state[<span class="hljs-string">"messages"</span>][-<span class="hljs-number">1</span>][<span class="hljs-string">"content"</span>]
    results = search_knowledge_base(last_message)
    <span class="hljs-keyword">return</span> {<span class="hljs-string">"knowledge_base_results"</span>: results}

3. Kontextbezogene Antworten generieren

Kombinieren Sie den Gesprächsverlauf und die Ergebnisse der Wissensdatenbank, um personalisiertere Antworten zu verfassen:

<span class="hljs-keyword">def</span> <span class="hljs-title function_">generate_response_node</span>(<span class="hljs-params">state: ChatbotState</span>):
    llm = ChatOpenAI(model=<span class="hljs-string">"gpt-3.5-turbo"</span>, temperature=<span class="hljs-number">0.7</span>)

    context = <span class="hljs-string">f"Knowledge base info: <span class="hljs-subst">{state.get(<span class="hljs-string">'knowledge_base_results'</span>, <span class="hljs-string">'No specific info found'</span>)}</span>"</span>
    conversation_history = <span class="hljs-string">""</span>.join(
        [<span class="hljs-string">f"<span class="hljs-subst">{msg[<span class="hljs-string">'role'</span>]}</span>: <span class="hljs-subst">{msg[<span class="hljs-string">'content'</span>]}</span>"</span> <span class="hljs-keyword">for</span> msg <span class="hljs-keyword">in</span> state[<span class="hljs-string">"messages"</span>][-<span class="hljs-number">3</span>:]]
    )

    prompt = <span class="hljs-string">f"""
    You are a helpful support assistant. Use the following context and conversation history to respond:

    Context: <span class="hljs-subst">{context}</span>
    Recent conversation:
    <span class="hljs-subst">{conversation_history}</span>

    Provide a helpful, concise response. If you cannot help, suggest escalation.
    """</span>

    response = llm.invoke(prompt)
    confidence = <span class="hljs-number">0.8</span> <span class="hljs-keyword">if</span> state.get(<span class="hljs-string">'knowledge_base_results'</span>) != <span class="hljs-string">"I couldn't find specific information about your query."</span> <span class="hljs-keyword">else</span> <span class="hljs-number">0.4</span>

    new_message = {<span class="hljs-string">"role"</span>: <span class="hljs-string">"assistant"</span>, <span class="hljs-string">"content"</span>: response.content}
    <span class="hljs-keyword">return</span> {
        <span class="hljs-string">"messages"</span>: state[<span class="hljs-string">"messages"</span>] + [new_message],
        <span class="hljs-string">"confidence_score"</span>: confidence,
        <span class="hljs-string">"escalation_needed"</span>: confidence < <span class="hljs-number">0.5</span>
    }

4. Eskalationen handhaben

Richten Sie bedingtes Routing ein, um zu bestimmen, ob eine Eskalation an einen menschlichen Agenten erforderlich ist:

<span class="hljs-keyword">def</span> <span class="hljs-title function_">should_escalate</span>(<span class="hljs-params">state: ChatbotState</span>):
    <span class="hljs-keyword">return</span> <span class="hljs-string">"escalate"</span> <span class="hljs-keyword">if</span> state.get(<span class="hljs-string">"escalation_needed"</span>, <span class="hljs-literal">False</span>) <span class="hljs-keyword">else</span> <span class="hljs-string">"complete"</span>

<span class="hljs-keyword">def</span> <span class="hljs-title function_">escalation_node</span>(<span class="hljs-params">state: ChatbotState</span>):
    escalation_message = {
        <span class="hljs-string">"role"</span>: <span class="hljs-string">"assistant"</span>, 
        <span class="hljs-string">"content"</span>: <span class="hljs-string">"I'm connecting you with a human agent who can better assist you."</span>
    }
    <span class="hljs-keyword">return</span> {<span class="hljs-string">"messages"</span>: state[<span class="hljs-string">"messages"</span>] + [escalation_message]}

5. Zusammenstellen des Workflows

Bringen Sie alles zusammen mit den Workflow-Funktionen von LangGraph:

workflow = StateGraph(ChatbotState)
workflow.add_node(<span class="hljs-string">"knowledge_search"</span>, knowledge_search_node)
workflow.add_node(<span class="hljs-string">"generate_response"</span>, generate_response_node)
workflow.add_node(<span class="hljs-string">"escalate"</span>, escalation_node)

workflow.add_edge(START, <span class="hljs-string">"knowledge_search"</span>)
workflow.add_edge(<span class="hljs-string">"knowledge_search"</span>, <span class="hljs-string">"generate_response"</span>)
workflow.add_conditional_edges(
    <span class="hljs-string">"generate_response"</span>,
    should_escalate,
    {<span class="hljs-string">"escalate"</span>: <span class="hljs-string">"escalate"</span>, <span class="hljs-string">"complete"</span>: END}
)
workflow.add_edge(<span class="hljs-string">"escalate"</span>, END)

chatbot = workflow.<span class="hljs-built_in">compile</span>()

<span class="hljs-comment"># Test the chatbot with a sample conversation</span>
initial_state = {
    <span class="hljs-string">"messages"</span>: [{<span class="hljs-string">"role"</span>: <span class="hljs-string">"user"</span>, <span class="hljs-string">"content"</span>: <span class="hljs-string">"I can't remember my password"</span>}],
    <span class="hljs-string">"user_id"</span>: <span class="hljs-string">"user_123"</span>,
    <span class="hljs-string">"conversation_id"</span>: <span class="hljs-string">"conv_456"</span>,
    <span class="hljs-string">"knowledge_base_results"</span>: <span class="hljs-literal">None</span>,
    <span class="hljs-string">"escalation_needed"</span>: <span class="hljs-literal">False</span>,
    <span class="hljs-string">"confidence_score"</span>: <span class="hljs-number">0.0</span>
}

result = chatbot.invoke(initial_state)
<span class="hljs-built_in">print</span>(result[<span class="hljs-string">"messages"</span>][-<span class="hljs-number">1</span>][<span class="hljs-string">"content"</span>])
<span class="hljs-comment"># Expected output: "To reset your password, click 'Forgot Password' on the login page. You can find this option on the main login screen..."</span>

Multi-Agent-Koordination

LangGraph unterstützt auch Workflows, bei denen mehrere Agenten an komplexen Aufgaben zusammenarbeiten. Ein Workflow zur Inhaltserstellung kann beispielsweise Agenten umfassen, die auf Recherche, Schreiben und Bearbeiten spezialisiert sind.

1. Gemeinsamen Status definieren

Verfolgen Sie den Fortschritt des Inhaltserstellungsprozesses mit einer gemeinsamen Statusstruktur:

<span class="hljs-keyword">from</span> typing <span class="hljs-keyword">import</span> TypedDict, <span class="hljs-type">List</span>

<span class="hljs-keyword">class</span> <span class="hljs-title class_">ContentCreationState</span>(<span class="hljs-title class_ inherited__">TypedDict</span>):
    topic: <span class="hljs-built_in">str</span>
    research_data: <span class="hljs-type">List</span>[<span class="hljs-built_in">str</span>]
    draft_content: <span class="hljs-built_in">str</span>
    edited_content: <span class="hljs-built_in">str</span>
    current_agent: <span class="hljs-built_in">str</span>
    quality_score: <span class="hljs-built_in">float</span>
    revision_count: <span class="hljs-built_in">int</span>

2. Spezialisierte Agenten

Weisen Sie Agenten für verschiedene Phasen des Workflows unterschiedliche Rollen zu:

• Forschungsagent: Sammelt Erkenntnisse und Daten.
• Schreibagent: Erstellt Inhalte auf der Grundlage von Recherchen.
• Bearbeitungsagent: Verfeinert den Entwurf hinsichtlich Klarheit und Professionalität.

<span class="hljs-keyword">def</span> <span class="hljs-title function_">research_agent</span>(<span class="hljs-params">state: ContentCreationState</span>):
    <span class="hljs-comment"># Perform research</span>
    research_results = [
        <span class="hljs-string">f"Key insight about <span class="hljs-subst">{state[<span class="hljs-string">'topic'</span>]}</span>: Market trends show increasing demand"</span>,
        <span class="hljs-string">f"Statistical data: 73% of users prefer <span class="hljs-subst">{state[<span class="hljs-string">'topic'</span>]}</span>-related solutions"</span>,
        <span class="hljs-string">f"Expert opinion: Industry leaders recommend focusing on <span class="hljs-subst">{state[<span class="hljs-string">'topic'</span>]}</span> benefits"</span>
    ]
    <span class="hljs-keyword">return</span> {
        <span class="hljs-string">"research_data"</span>: research_results,
        <span class="hljs-string">"current_agent"</span>: <span class="hljs-string">"research_complete"</span>
    }

<span class="hljs-keyword">def</span> <span class="hljs-title function_">writing_agent</span>(<span class="hljs-params">state: ContentCreationState</span>):
    llm = ChatOpenAI(model=<span class="hljs-string">"gpt-4"</span>, temperature=<span class="hljs-number">0.8</span>)
    research_summary = <span class="hljs-string">""</span>.join(state[<span class="hljs-string">"research_data"</span>])
    prompt = <span class="hljs-string">f"""
    Write an article about <span class="hljs-subst">{state[<span class="hljs-string">'topic'</span>]}</span> using this research:
    <span class="hljs-subst">{research_summary}</span>

    Create informative content that incorporates the key insights.
    """</span>
    response = llm.invoke(prompt)
    <span class="hljs-keyword">return</span> {
        <span class="hljs-string">"draft_content"</span>: response.content,
        <span class="hljs-string">"current_agent"</span>: <span class="hljs-string">"writing_complete"</span>
    }

<span class="hljs-keyword">def</span> <span class="hljs-title function_">editing_agent</span>(<span class="hljs-params">state: ContentCreationState</span>):
    llm = ChatOpenAI(model=<span class="hljs-string">"gpt-4"</span>, temperature=<span class="hljs-number">0.3</span>)
    prompt = <span class="hljs-string">f"""
    Edit and improve this content for clarity, flow, and engagement:
    <span class="hljs-subst">{state[<span class="hljs-string">'draft_content'</span>]}</span>

    Focus on:
    - Clear structure and transitions
    - Professional tone
    - Factual accuracy
    """</span>
    response = llm.invoke(prompt)
    quality_score = <span class="hljs-number">0.85</span> <span class="hljs-keyword">if</span> <span class="hljs-built_in">len</span>(response.content) > <span class="hljs-built_in">len</span>(state[<span class="hljs-string">"draft_content"</span>]) * <span class="hljs-number">0.8</span> <span class="hljs-keyword">else</span> <span class="hljs-number">0.6</span>
    <span class="hljs-keyword">return</span> {
        <span class="hljs-string">"edited_content"</span>: response.content,
        <span class="hljs-string">"quality_score"</span>: quality_score,
        <span class="hljs-string">"current_agent"</span>: <span class="hljs-string">"editing_complete"</span>
    }

3. Qualitätskontrolle und Revisionen

Führen Sie eine Logik ein, um die Ausgabe auszuwerten und zu verfeinern:

<span class="hljs-keyword">def</span> <span class="hljs-title function_">quality_check</span>(<span class="hljs-params">state: ContentCreationState</span>):
    <span class="hljs-keyword">if</span> state[<span class="hljs-string">"quality_score"</span>] < <span class="hljs-number">0.7</span> <span class="hljs-keyword">and</span> state[<span class="hljs-string">"revision_count"</span>] < <span class="hljs-number">2</span>:
        <span class="hljs-keyword">return</span> <span class="hljs-string">"revise"</span>
    <span class="hljs-keyword">return</span> <span class="hljs-string">"complete"</span>

<span class="hljs-keyword">def</span> <span class="hljs-title function_">revision_coordinator</span>(<span class="hljs-params">state: ContentCreationState</span>):
    <span class="hljs-keyword">return</span> {
        <span class="hljs-string">"current_agent"</span>: <span class="hljs-string">"revision_needed"</span>,
        <span class="hljs-string">"revision_count"</span>: state[<span class="hljs-string">"revision_count"</span>] + <span class="hljs-number">1</span>
    }

Die Flexibilität von LangGraph ermöglicht die nahtlose Integration solcher Multi-Agent-Workflows und stellt sicher, dass Aufgaben effizient erledigt werden und gleichzeitig qualitativ hochwertige Ergebnisse erzielt werden.

sbb-itb-23997f1

Visuelle Workflow-Automatisierung mit Latenknoten

LangGraph bietet einen tiefen Einblick in die graphenbasierte KI-Architektur, doch nicht jeder Entwickler möchte sich mit den Komplexitäten der Graphenprogrammierung auseinandersetzen. Wer einen intuitiveren Ansatz sucht, findet mit visuellen Entwicklungsplattformen wie Latenode die Möglichkeit, zustandsbehaftete Workflows ohne umfassende Programmierkenntnisse zu erstellen. Dieser Vergleich zeigt, wie visuelle Tools die Automatisierung von KI-Workflows vereinfachen und beschleunigen können.

Latenode vs. LangGraph

Der Unterschied zwischen Latenode und LangGraph liegt in ihrem Ansatz zur Erstellung von KI-Workflows. LangGraph verfolgt einen Code-First-Ansatz und erfordert von Entwicklern die explizite Definition von Zuständen, Knoten und Kanten. Dies kann für Neulinge auf diesem Gebiet entmutigend sein. Latenode hingegen verfolgt eine Visual-First-Philosophie. Seine Drag-and-Drop-Oberfläche ermöglicht es Benutzern, anspruchsvolle Workflows zu entwerfen, ohne große Mengen Code schreiben zu müssen. Dadurch werden Aufgaben wie die Erstellung eines Chatbots mit Speicher deutlich einfacher.

Debugging und Wartung

Codebasierte Systeme erfordern oft eine sorgfältige Verfolgung der Ausführungspfade, die mit zunehmender Komplexität der Workflows zunehmend komplexer werden kann. Latenode vereinfacht diesen Prozess mit seiner visuellen Oberfläche und bietet Echtzeitansichten des Ausführungsverlaufs und des Datenflusses zwischen Knoten. Dies vereinfacht das Debuggen und die laufende Wartung.

Vergleich der Lernkurven

Code-First-Frameworks wie LangGraph erfordern ein solides Verständnis von Programmierung und Datenstrukturen, was für Anfänger eine Hürde darstellen kann. Latenode beseitigt diese Hürde, indem es Benutzern ermöglicht, sich auf die Workflow-Logik statt auf die Syntax zu konzentrieren. Während LangGraph erfahrenen Entwicklern Flexibilität bietet, legt Latenode Wert auf Einfachheit und Geschwindigkeit, sodass Benutzer funktionale KI-Workflows schnell zum Laufen bringen können.

Durch die Übersetzung der Kernkonzepte von LangGraph in ein visuelles Format macht Latenode die Workflow-Erstellung zugänglicher und behält gleichzeitig die Prinzipien des Stateful-AI-Designs bei.

Anwenden von LangGraph-Konzepten in Latenode

Latenode integriert viele der grundlegenden Ideen von LangGraph – wie Zustandsverwaltung, bedingtes Routing und Multi-Agent-Task-Orchestrierung – in sein benutzerfreundliches visuelles Framework:

• Staatsverwaltung: In codebasierten Systemen erfordert die Verwaltung des Konversationsverlaufs häufig die Erstellung benutzerdefinierter Datenstrukturen. Latenode handhabt dies visuell mit Knoten, die die Statusverfolgung vereinfachen.
• Bedingte Logik: Das Schreiben von Entscheidungscode kann zeitaufwändig sein. Latenode ersetzt dies durch Entscheidungsknoten, mit denen Benutzer Bedingungen visuell festlegen können.
• Multi-Agent-Workflows: Komplexe Aufgaben wie die Koordinierung von Recherche, Schreiben und Bearbeiten können in Latenode in separate visuelle Knoten aufgeteilt werden, wodurch klare und überschaubare Pipelines entstehen.

Diese visuelle Darstellung der wichtigsten Prinzipien stellt sicher, dass auch komplexe KI-Workflows zugänglich und einfach zu verwalten bleiben.

Vorteile von Latenode für Anfänger

Schnellstart für neue Benutzer

Mit Latenode können Anfänger nahezu sofort produktionsreife Workflows erstellen. Durch die Konzentration auf das Workflow-Design statt auf die Programmiersyntax können Benutzer Ideen mit minimaler Verzögerung in funktionierende Lösungen umsetzen.

Nahtlose KI-Integration

Latenode stellt eine direkte Verbindung zu über 200 KI-Modellen her und übernimmt API-Aufgaben automatisch, sodass keine manuelle Integration erforderlich ist.

Verbesserte Zusammenarbeit

Die visuelle Natur von Latenode erleichtert das Verständnis und die Überprüfung von Arbeitsabläufen. Nicht-technische Teammitglieder und Stakeholder können am Entwicklungsprozess teilnehmen, ohne sich in den Code vertiefen zu müssen.

Mühelose Skalierbarkeit

Mit integrierten Datenbank- und Browser-Automatisierungsfunktionen lässt sich Latenode problemlos von ersten Experimenten bis zur Produktion im großen Maßstab skalieren, und das alles ohne unnötige Komplexität.

Nächste Schritte und Ressourcen

Um Ihre LangGraph-Projekte weiterzuentwickeln, müssen Sie sie skalieren, verfeinern und als robuste, produktionsreife Anwendungen bereitstellen. So gehen Sie diese nächste Phase effektiv an.

Skalieren und Optimieren von Workflows

Wenn Ihre LangGraph-Anwendungen sowohl an Benutzerbasis als auch an Komplexität zunehmen, ist eine reibungslose Leistung unerlässlich. Ein wichtiger Bereich, auf den Sie sich konzentrieren sollten, ist SpeicherverwaltungAnstatt ganze Gesprächsverläufe aufzubewahren, sollten Sie ältere Interaktionen komprimieren und nur die aktuellsten Gespräche zugänglich machen. Dies trägt zur Aufrechterhaltung der Effizienz bei, ohne den Kontext zu beeinträchtigen.

Ein weiterer wichtiger Schritt ist DatenbankintegrationDer Umstieg von In-Memory-Speicher auf eine datenbankgestützte Lösung ermöglicht Ihnen eine effektivere Verwaltung der Speichernutzung. Außerdem werden Ihre Workflows von temporären Experimenten zu zuverlässigen, persistenten Anwendungen.

Für eine verbesserte Leistung, parallele Verarbeitung kann die gleichzeitige Ausführung mehrerer Agenten ermöglichen. Darüber hinaus können Fehlerbehandlungsmechanismen wie exponentielles Backoff Leistungsschalter kann dazu beitragen, kaskadierende Fehler zu verhindern und die Systemstabilität unter Belastung aufrechtzuerhalten.

Durch die Implementierung dieser Optimierungen legen Sie eine solide Grundlage für fortgeschrittenes Lernen und produktionsreife Anwendungen.

Lernmittel

Um Ihr Verständnis zu vertiefen, offizielle LangGraph-Dokumentation (langchain-ai.github.io/langgraph) ist eine unschätzbar wertvolle Ressource. Es bietet detaillierte API-Referenzen, Architekturrichtlinien und praktische Beispiele zu Themen wie Zustandspersistenz, Human-in-the-Loop-Workflows und Multi-Agenten-Koordination.

Die LangGraph GitHub-Repository ist eine weitere hervorragende Inspirationsquelle. Es enthält eine Reihe von Beispielprojekten, von einfachen Chatbots bis hin zu anspruchsvollen Forschungsassistenten, und zeigt, wie Unternehmen LangGraph verwenden, um skalierbare KI-Anwendungen zu erstellen.

Weitere Unterstützung finden Sie unter Online-Communities YouTube-Kanäle LangGraph gewidmet. Diese Plattformen bieten oft Echtzeit-Beratung und ausführliche Tutorials zu fortgeschrittenen Mustern.

Produktionsbereitstellung

Sobald Ihre Workflows optimiert sind, besteht der nächste Schritt darin, Ihre Anwendung in einer sicheren und skalierbaren Umgebung bereitzustellen. Beginnen Sie mit der Konfiguration Ihres Systems für die Verarbeitung API-Ratenbegrenzungen und verwalten Sie Token effektiv durch Pooling und Überwachung. Tools wie Prometheus or Grafana kann Echtzeit-Systemeinblicke liefern, während strenge Sicherheitsmaßnahmen – wie Eingabebereinigung, Ausgabefilterung und verschlüsselte Statusspeicherung – zum Schutz Ihrer Anwendung beitragen.

Für Teams, die die Bereitstellung optimieren möchten, Latenknoten bietet eine leistungsstarke Lösung. Die visuelle Plattform vereinfacht die Komplexität von Produktionsumgebungen mit integrierten Funktionen wie automatische Skalierung, Echtzeit-Überwachung und integriertes Datenbankmanagement. Latenode unterstützt über 300 App-Integrationen und mehr als 200 KI-Modelle und bietet gebrauchsfertige Komponenten, die Ihren Weg vom Konzept bis zur Bereitstellung beschleunigen können.

Mit Latenode können Sie fortschrittliche Techniken implementieren und produktionsreife Workflows erstellen, ohne Kompromisse bei der Komplexität einzugehen. Diese KI-Orchestrierungsplattform ermöglicht es Ihnen, sich auf die Verfeinerung Ihrer Anwendungslogik zu konzentrieren und gleichzeitig die Infrastrukturherausforderungen nahtlos zu bewältigen.

FAQs

Wie macht das graphenbasierte Design von LangGraph KI-Workflows flexibler als lineare Tools?

Das graphenbasierte Framework von LangGraph bietet ein neues Maß an Flexibilität für KI-Workflows, indem es nichtlineare Prozesse wie Schleifen, bedingte Verzweigungen und die Zusammenarbeit mehrerer Agenten. Im Gegensatz zu herkömmlichen linearen Tools, die einer starren, schrittweisen Abfolge folgen, ermöglicht LangGraph die dynamische Anpassung von Arbeitsabläufen basierend auf Echtzeiteingaben und komplexen Anforderungen.

Dieses Design ist besonders effektiv für den Bau modulare, skalierbare und persistente Workflows, vereinfacht die Verwaltung komplexer KI-Aufgaben wie mehrstufige Interaktionen, Human-in-the-Loop-Operationen und die prozessübergreifende Zustandserhaltung. Mit diesem dynamischen Ansatz ermöglicht LangGraph Entwicklern die Entwicklung intelligenterer, anpassungsfähigerer KI-Systeme, die sich stetig weiterentwickelnden Anforderungen präzise gerecht werden.

Was macht LangGraph für die Verwaltung des Konversationskontexts in Chatbots so effektiv?

LangGraph zeichnet sich durch die Verwaltung des Konversationskontexts in Chatbots aus, dank seiner Stateful Memory-Funktionen. Diese Funktion ermöglicht es Chatbots, frühere Interaktionen abzurufen, den Kontext über mehrere Austausche hinweg aufrechtzuerhalten und komplexe Arbeitsabläufe mit mehreren Schritten effizient zu verwalten.

Mit Persistente Zustandsverwaltung und dynamische Kontextfenster ermöglichen flüssigere und natürlichere Konversationen. LangGraph begegnet den Herausforderungen traditioneller linearer Methoden und bietet Nutzern, die mit Chatbots interagieren, ein nahtloseres und ansprechenderes Erlebnis.

Wie können Anfänger Latenode verwenden, um KI-Workflows zu erstellen, ohne fortgeschrittene Programmierkenntnisse zu benötigen?

Anfänger können schnell in die Erstellung von KI-Workflows mit Latenode eintauchen, dank seiner intuitive No-Code-PlattformÜber die visuelle Benutzeroberfläche der Plattform können Benutzer Arbeitsabläufe durch Ziehen und Ablegen von Komponenten entwerfen, sodass keine fortgeschrittenen Programmierkenntnisse erforderlich sind.

Mit Zugriff auf über 300 vorgefertigte IntegrationenLatenode optimiert den Prozess der Tool-Verbindung und Aufgabenautomatisierung. Dieses Setup vereinfacht und beschleunigt die Entwicklung zustandsbehafteter KI-Anwendungen. Durch den Fokus auf Benutzerfreundlichkeit ermöglicht Latenode den Anwendern, KI-Konzepte zu erkunden und anzuwenden, ohne sich in komplexen Trial-and-Error-Prozessen zu verlieren. Dies ermöglicht eine schnellere Bereitstellung effektiver Lösungen.

Ähnliche Artikel

• Was ist LangGraph
• LangGraph Multi-Agent Systems: Vollständiges Tutorial und Beispiele
• LangChain vs. LangGraph: Vollständiger Vergleichsleitfaden für Entwickler
• Was ist LangGraph? Vollständiger Leitfaden zum Graph Framework von LangChain