====== LangGraph Basis principes ======
🗂️ [[start|Terug naar start]]\\
♻️ 🗂️ [[langgraph|LangGraph start]]


===== LangGraph Instaleren =====
<code>pip install --quiet -U langgraph</code>

===== Kernbegrippen (bronnen): =====

[[https://www.youtube.com/watch?v=R-o_a6dvzQM|Video: Aan het begin van deze video worden de Kernbegrippen van LangGraph keurig op een rijtje gezet en uitgebreid besproken]]\\
🔸 Verder wordt in deze video ook Google gebruikt om te zoeken op het web en een Python web-scraper //(BeautifulSoup)// om de content van een webpagina binnen te halen  

💡Hieronder de onderdelen zoals deze in het begin van de [[https://www.youtube.com/watch?v=R-o_a6dvzQM|video]] worden beschreven\\
[[https://colab.research.google.com/github/langchain-ai/langchain-academy/blob/main/module-1/simple-graph.ipynb|Simple Graph]] //(als voorbeeld van de code hieronder)//

----

==== State ====

{{ graph_1.png?380}}
De **State** is een dictionary met informatie over het proces\\
De **State** word gelezen en gevuld door de **Graph**\\
Doel van de **State** is om alle activiteiten van de **Agent** bij te houden //(te registreren)// 

Definieer eerst de [[https://langchain-ai.github.io/langgraph/concepts/low_level/#state|State]] //(toestand)// van de Graph //(grafiek)//.\\
Het toestandsschema dient als invoerschema voor alle knooppunten en randen in de grafiek.\\
Laten we de TypedDict-klasse van de typmodule van Python gebruiken als ons schema, dat typehints biedt voor de sleutels.

<code>from typing_extensions import TypedDict

class State(TypedDict):
    graph_state: str</code>


----


==== Node ====

{{ graph_2.png?380}}
In LangGraph **Nodes** kunnen **agenten** zijn maar ook **Tools**

**[[https://langchain-ai.github.io/langgraph/concepts/low_level/#nodes|Nodes]] zijn gewoon python-functies**.\\
🔸 Het eerste positionele argument is de state, zoals hierboven gedefinieerd.\\
🔸 Omdat de state een TypedDict is met schema zoals hierboven gedefinieerd, kan elke node toegang krijgen tot de sleutel, graph_state, met state['graph_state'].\\
🔸 Elke node retourneert een nieuwe waarde van de state-sleutel graph_state.\\
🔸 Standaard [[https://langchain-ai.github.io/langgraph/concepts/low_level/#reducers|overschrijft]] de nieuwe waarde die door elke node wordt geretourneerd de vorige state-waarde.

<code>def node_1(state):
    print("---Node 1---")
    return {"graph_state": state['graph_state'] +" I am"}

def node_2(state):
    print("---Node 2---")
    return {"graph_state": state['graph_state'] +" happy!"}

def node_3(state):
    print("---Node 3---")
    return {"graph_state": state['graph_state'] +" sad!"}</code>

----



==== Edge ====

{{ graph_3.png?380}}

[[https://langchain-ai.github.io/langgraph/concepts/low_level/#edges|Edges]] verbinden de nodes.\\
Normale Edges worden gebruikt als u bijvoorbeeld altijd van node_1 naar node_2 wilt gaan.\\
[[https://langchain-ai.github.io/langgraph/reference/graphs/?h=conditional+edge#stategraph|Voorwaardelijke Edges]] worden gebruikt als u optioneel tussen nodes wilt routeren.\\
Voorwaardelijke Edges worden geïmplementeerd als functies die het volgende node retourneren dat u wilt bezoeken op basis van een bepaalde logica.

<code>import random
from typing import Literal

def decide_mood(state) -> Literal["node_2", "node_3"]:
    
    # Often, we will use state to decide on the next node to visit
    user_input = state['graph_state'] 
    
    # Here, let's just do a 50 / 50 split between nodes 2, 3
    if random.random() < 0.5:

        # 50% of the time, we return Node 2
        return "node_2"
    
    # 50% of the time, we return Node 3
    return "node_3"</code>
----

==== Graphs ====

{{ graph_4.png?380}}
Een **Graph** bestaat uit **Nodes** en **Edges**\\
Een **Graph** leest en schrijft van en naar een **State**

[[https://colab.research.google.com/github/langchain-ai/langchain-academy/blob/main/module-1/simple-graph.ipynb|De eenvoudigste graph (grafiek) - Coab]]

[[https://langchain-ai.github.io/langgraph/concepts/low_level/#stategraph|De StateGraph-klasse]] is de grafiekklasse die we kunnen gebruiken.\\
Eerst initialiseren we een StateGraph met de State-klasse die we hierboven hebben gedefinieerd.\\
Vervolgens voegen we onze knooppunten en randen toe.\\
🔸 We gebruiken **[[https://langchain-ai.github.io/langgraph/concepts/low_level/#start-node|de START-knoop]]** (node), een speciaal knooppunt dat gebruikersinvoer naar de grafiek stuurt, om aan te geven waar onze grafiek moet beginnen.\\
🔸 De **[[https://langchain-ai.github.io/langgraph/concepts/low_level/#end-node|END-knoop]]** (node) is een speciaal knooppunt (node) dat een eindknooppunt vertegenwoordigt.\\
Tot slot [[https://langchain-ai.github.io/langgraph/concepts/low_level/#compiling-your-graph|compileren we onze graph]] (grafiek) om een ​​paar basiscontroles op de grafiekstructuur uit te voeren.\\

<code>from typing import TypedDict
from langgraph.graph import StateGraph, START, END

# Build graph
builder = StateGraph(State)
builder.add_node("node_1", node_1)
builder.add_node("node_2", node_2)
builder.add_node("node_3", node_3)

# Logic
builder.add_edge(START, "node_1")
builder.add_conditional_edges("node_1", decide_mood)
builder.add_edge("node_2", END)
builder.add_edge("node_3", END)

# Add
graph = builder.compile()</code>

💡 [[#mens_in_de_loop|Variant met Mens in de Loop Vraag aan gebruiker of we verder moeten gaan of niet]]✨

=== Graph Invocation ===
De gecompileerde grafiek implementeert het [[https://python.langchain.com/v0.1/docs/expression_language/interface/|uitvoerbare protocol]].\\
Dit biedt een standaardmanier om LangChain-componenten uit te voeren.\\
invoke is een van de standaardmethoden in deze interface.\\
De invoer is een woordenboek {"graph_state": "Hi, this is lance."}, dat de beginwaarde voor onze grafiekstatusdict instelt.\\
Wanneer invoke wordt aangeroepen, start de grafiek met de uitvoering vanaf het START-knooppunt.\\
Het gaat door de gedefinieerde knooppunten (node_1, node_2, node_3) in volgorde.\\
De voorwaardelijke rand gaat van knooppunt 1 naar knooppunt 2 of 3 met behulp van een 50/50-beslissingsregel.\\
Elke knooppuntfunctie ontvangt de huidige status en retourneert een nieuwe waarde, die de grafiekstatus overschrijft.\\
De uitvoering gaat door totdat het END-knooppunt is bereikt.

<code>graph.invoke({"graph_state" : "Hi, this is Lance."})</code>

Output:
<code>---Node 1---
---Node 3---
{'graph_state': 'Hi, this is Lance. I am sad!'}</code>

invoke voert de hele grafiek synchroon uit.\\
Dit wacht tot elke stap is voltooid voordat het naar de volgende gaat.\\
Het retourneert de uiteindelijke status van de grafiek nadat alle knooppunten zijn uitgevoerd.\\
In dit geval retourneert het de status nadat node_3 is voltooid:

<code>{'graph_state': 'Hi, this is Lance. I am sad!'}</code>


===== Schematisch Overzicht Basis =====

{{ LangGraph_basis.png?1000 }}

----

===== Mens in de Loop =====
[[https://medium.com/@cobusgreyling/ai-agents-with-human-in-the-loop-f910d0c0384b|Bron tutorial]]

binnen LangGraph kan een interrupt worden toegevoegd wanneer een menselijke tussenkomst vereist is. Een interrupt kan ook worden toegevoegd voor bepaalde tools waarbij wordt aangenomen dat een tool niet kan worden uitgevoerd voordat een of meer mensen goedkeuring hebben gegeven.

Daarom kan voor bepaalde tools een menselijke interrupt worden toegevoegd, of binnen de grafiekomgeving van LangGraph kan een knooppunt waar menselijke tussenkomst vereist is als zodanig worden gedefinieerd. De HITL kan voorafgaand aan of na een bepaald knooppunt worden geplaatst, zodat de menselijke betrokkenheid kan zijn om goedkeuring te verlenen of een transactie na de interactie te controleren.

<code>user_approval = input(“Do you want to go to Step 3? (yes/no): “)</code>

<code>from typing import TypedDict
from langgraph.graph import StateGraph, START, END
from langgraph.checkpoint.memory import MemorySaver


class State(TypedDict):
    input: str


def step_1(state):
    print("---Step 1---")
    pass


def step_2(state):
    print("---Step 2---")
    pass


def step_3(state):
    print("---Step 3---")
    pass


builder = StateGraph(State)
builder.add_node("step_1", step_1)
builder.add_node("step_2", step_2)
builder.add_node("step_3", step_3)
builder.add_edge(START, "step_1")
builder.add_edge("step_1", "step_2")
builder.add_edge("step_2", "step_3")
builder.add_edge("step_3", END)

# Set up memory
memory = MemorySaver()

# Add
graph = builder.compile(checkpointer=memory, interrupt_before=["step_3"])</code>


{{ gr_1.png?800 }}
{{ gr_2.png?800 }}

[[https://medium.com/@cobusgreyling/ai-agents-with-human-in-the-loop-f910d0c0384b|Bron tutorial]]

----

==== ✨ Human-in-the-Loop ✨ ====

**[[https://medium.com/@kbdhunga/implementing-human-in-the-loop-with-langgraph-ccfde023385c|Uitgebreidere versie Human in The Loop - Agent met GUI]]** ✨

----




===== Specials =====
[[https://medium.com/@lucas.dahan/hands-on-langgraph-building-a-multi-agent-assistant-06aa68ed942f|Hands on LangGraph — Building a multi agent assistant]]\\
[[https://cobusgreyling.medium.com/ai-agents-with-human-in-the-loop-f910d0c0384b|AI Agents With Human In The Loop]]\\
[[https://medium.com/@kbdhunga/implementing-human-in-the-loop-with-langgraph-ccfde023385c|Implementing Human-in-the-Loop with LangGraph]]\\
**[[https://academy.langchain.com/courses/take/intro-to-langgraph/lessons/58238107-course-overview|Cursus: Introduction to LangGraph]]**

----

===== Links =====

**Cursus LangGraph in de LangChain acaddemy**\\
**[[https://academy.langchain.com/courses/take/intro-to-langgraph/lessons/58238107-course-overview|Cursus: Introduction to LangGraph]]✨**

[[https://www.langchain.com/langgraph|Langgraph Home]]\\
[[https://langchain-ai.github.io/langgraph/|Building language agents as graphs]]

[[https://academy.langchain.com/courses/intro-to-langgraph|LangChain Academy]]\\
**[[https://academy.langchain.com/courses/take/intro-to-langgraph/lessons/58238107-course-overview|Cursus: Introduction to LangGraph]]✨**

**Tutorials:**\\
[[https://bhavikjikadara.medium.com/langgraph-a-comprehensive-guide-for-beginners-ef17d3dd5383|LangGraph: A Comprehensive Guide for Beginners]]\\
[[https://medium.com/@cplog/building-tool-calling-conversational-ai-with-langchain-and-langgraph-a-beginners-guide-8d6986cc589e|Building Tool-Calling Conversational AI with LangChain and LangGraph: A Beginner’s Guide]]\\
[[https://cobusgreyling.medium.com/ai-agents-with-human-in-the-loop-f910d0c0384b|AI Agents With Human In The Loop]]\\
[[https://cobusgreyling.medium.com/langgraph-agents-by-langchain-c1f6ebd86c38|LangGraph Agents By LangChain (ook met Human In The Loop)]]\\
[[https://medium.com/@kbdhunga/implementing-human-in-the-loop-with-langgraph-ccfde023385c|Implementing Human-in-the-Loop with LangGraph (incl. tools)]]\\
[[https://blog.gopenai.com/building-stateful-applications-with-langgraph-860de3c9fa90|Building Stateful Applications with LangGraph (incl tools)]]\\
[[https://medium.com/@lucas.dahan/hands-on-langgraph-building-a-multi-agent-assistant-06aa68ed942f|Hands on LangGraph — Building a multi agent assistant]]\\