Langgraph End to End

https://github.com/sunnysavita10/langgraph-end-to-end
Admin
This project demonstrates an end-to-end application using LangGraph, a framework for building...
Tokens:90,106
Snippets:686
Trust Score:9.4
Update:1 year ago
Show doc for...
Tokens:
Raw
### Document Loading, Splitting, and Retrieval Setup

Source: https://github.com/sunnysavita10/langgraph-end-to-end/blob/main/langgraph_from_scratch/scratch.ipynb

Loads text files from a directory, splits them into chunks, creates a Chroma vector store, and sets up a retriever for semantic search. Requires 'langchain_community', 'langchain_core', and an 'embeddings' object.

```python
from langchain_community.document_loaders import TextLoader, DirectoryLoader
from langchain_community.vectorstores import Chroma
from langchain.text_splitter import RecursiveCharacterTextSplitter
loader=DirectoryLoader("../data2",glob="./*.txt",loader_cls=TextLoader)
docs=loader.load()
text_splitter=RecursiveCharacterTextSplitter(
    chunk_size=100,
    chunk_overlap=50
)
new_docs = text_splitter.split_documents(documents=docs)
doc_strings = [doc.page_content for doc in new_docs]

db = Chroma.from_documents(new_docs, embeddings)
retriever = db.as_retriever(search_kwargs={"k": 3})

query = "what is meta llama3?"
docs = retriever.get_relevant_documents(query)
print(docs[0].metadata)
print(docs[0].page_content)

for doc in docs:
    print(doc)
```

--------------------------------

### RAG Setup with LangChain and ChromaDB

Source: https://github.com/sunnysavita10/langgraph-end-to-end/blob/main/langgraph_from_scratch/scratch.ipynb

Sets up a Retrieval-Augmented Generation (RAG) pipeline. It loads documents from a directory, splits them into chunks, creates embeddings, and stores them in ChromaDB for efficient retrieval.

```python
from langchain_community.document_loaders import TextLoader, DirectoryLoader
from langchain_community.vectorstores import Chroma
from langchain.text_splitter import RecursiveCharacterTextSplitter

# Load documents from a directory
loader2=DirectoryLoader("../data2",glob="./*.txt",loader_cls=TextLoader)
docs2=loader2.load()

# Split documents into smaller chunks
text_splitter=RecursiveCharacterTextSplitter(
    chunk_size=100,
    chunk_overlap=50
)
new_docs2 = text_splitter.split_documents(documents=docs2)
doc_strings2 = [doc.page_content for doc in new_docs2]

# Create a ChromaDB vector store and retriever
db2 = Chroma.from_documents(new_docs2, embeddings)
retriever2 = db2.as_retriever(search_kwargs={"k": 3})

# Example query and retrieval
query = "Tell me about Japan's Industrial Growth?"
docs = retriever2.get_relevant_documents(query)
print(docs[0].metadata)
print(docs[0].page_content)

for doc in docs:
    print(doc)
```

--------------------------------

### Example Question

Source: https://github.com/sunnysavita10/langgraph-end-to-end/blob/main/agent_based_rag/self_rag.ipynb

An example of a user's initial question.

```python
question="who is a current indian prime minister?"
```

--------------------------------

### Example LLM Output and Prompt Template

Source: https://github.com/sunnysavita10/langgraph-end-to-end/blob/main/langgraph_from_scratch/scratch.ipynb

Demonstrates an example prompt template for topic selection and a simulated LLM output that conforms to the Pydantic model structure.

```python
# Example prompt template for topic selection
from langchain.prompts import PromptTemplate
prompt_template = PromptTemplate(
    input_variables=["user_input"],
    template="Based on the input: {user_input}, please select a topic and provide reasoning."
)

# Simulate generating an output (in a real scenario, this would be from an LLM)
user_input = "Discuss advancements in AI."
output = {
    "Topic": "Advancements in AI",
    "Reasoning": "AI has significantly improved in recent years due to advances in deep learning."
}

```

--------------------------------

### Example Input for Multiplication

Source: https://github.com/sunnysavita10/langgraph-end-to-end/blob/main/langgraph_from_scratch/scratch.ipynb

Defines an example input dictionary for invoking the compiled LangGraph application with a multiplication query.

```python
input1={"messages": ["What is 123 * 456?"]}
```

--------------------------------

### Example Prompt Template for Classification

Source: https://github.com/sunnysavita10/langgraph-end-to-end/blob/main/langgraph_from_scratch/langgraph_scratch.ipynb

Provides an example of a prompt template used for classifying user queries. It specifies the task, categories, and includes placeholders for the user query and format instructions, guiding the LLM's response format.

```python
template="""
    Your task is to classify the given user query into one of the following categories: [India, Not Related]. 
    Only respond with the category name and nothing else.

    User query: "Tell me about India's Industrial Growth"
    The output should be formatted as a JSON instance that conforms to the JSON schema below.

    As an example, for the schema {"properties": {"foo": {"title": "Foo", "description": "a list of strings", "type": "array", "items": {"type": "string"}}}, "required": ["foo"]}
    the object {"foo": ["bar", "baz"]} is a well-formatted instance of the schema. The object {"properties": {"foo": ["bar", "baz"]}} is not well-formatted.

    Here is the output schema:
    ```
    {"properties": {"Topic": {"description": "Selected Topic", "title": "Topic", "type": "string"}, "Reasoning": {"description": "Reasoning behind topic selection", "title": "Reasoning", "type": "string"}}, "required": ["Topic", "Reasoning"]}
        """
```

--------------------------------

### Langchain PydanticOutputParser get_format_instructions

Source: https://github.com/sunnysavita10/langgraph-end-to-end/blob/main/langgraph_from_scratch/scratch.ipynb

Retrieves the format instructions for the PydanticOutputParser, which can be used to guide LLM output generation to match the Pydantic model's schema.

```python
print(parser.get_format_instructions())
```

--------------------------------

### Streaming Invocation Example

Source: https://github.com/sunnysavita10/langgraph-end-to-end/blob/main/langgraph_from_scratch/scratch.ipynb

Demonstrates how to stream the invocation of the compiled LangGraph application with an input and prints the output from each step.

```python
input={"messages": ["What is LLM?"]}

for output in app6.stream(input1):
    for key,value in output.items():
        print(f"here is output from {key}")
        print("_______")
        print(value)
        print("\n")
```

--------------------------------

### Initializing an Empty Dictionary

Source: https://github.com/sunnysavita10/langgraph-end-to-end/blob/main/langgraph_from_scratch/scratch.ipynb

Creates an empty dictionary named 'mydict'.

```python
mydict={}
```

--------------------------------

### Operator Addition Example

Source: https://github.com/sunnysavita10/langgraph-end-to-end/blob/main/langgraph_from_scratch/scratch.ipynb

Demonstrates the use of the operator.add function to perform addition.

```python
operator.add(10, 15)
```

--------------------------------

### Input State Example

Source: https://github.com/sunnysavita10/langgraph-end-to-end/blob/main/chatbot_with_langgraph/chatbot.ipynb

Provides an example of the input state format required for invoking the LangGraph application, consisting of a 'messages' key with a list of strings.

```Python
input={"messages":["hi, my name is sunny"]}
```

--------------------------------

### LangGraph Imports

Source: https://github.com/sunnysavita10/langgraph-end-to-end/blob/main/multiagent_system/multiagent.ipynb

Imports core components from LangGraph for building stateful graphs, including StateGraph, END, START, and create_react_agent.

```Python
import functools
import operator
from typing import Sequence, TypedDict
from langchain_core.messages import BaseMessage
from langgraph.graph import END, StateGraph, START
from langgraph.prebuilt import create_react_agent
```

--------------------------------

### Get Format Instructions for Parser

Source: https://github.com/sunnysavita10/langgraph-end-to-end/blob/main/langgraph_from_scratch/langgraph_scratch.ipynb

Retrieves the format instructions from the PydanticOutputParser. These instructions guide the language model on how to structure its output to conform to the Pydantic schema.

```python
print(parser.get_format_instructions())
```

--------------------------------

### Define and Compile LangGraph Workflow

Source: https://github.com/sunnysavita10/langgraph-end-to-end/blob/main/multiagent_system/research_analyst_multiagent.ipynb

Sets up the LangGraph workflow by creating a StateGraph, adding the 'researcher' and 'chart_generator' nodes, defining the edge from the start node to the researcher, and compiling the application.

```python
from langgraph.graph import StateGraph, START

workflow = StateGraph(MessagesState)
workflow.add_node("researcher", research_node)
workflow.add_node("chart_generator", chart_node)

workflow.add_edge(START, "researcher")
app = workflow.compile()
```

--------------------------------

### Example System Prompt Usage

Source: https://github.com/sunnysavita10/langgraph-end-to-end/blob/main/multiagent_system/research_analyst_multiagent.ipynb

Demonstrates calling the `make_system_prompt` function with specific instructions for an agent that can only do research and works with a chart generator colleague.

```python
make_system_prompt(
        "You can only do research. You are working with a chart generator colleague."
    )
```

--------------------------------

### Environment Variable Setup

Source: https://github.com/sunnysavita10/langgraph-end-to-end/blob/main/Pre-requist_for_langgraph/agents_pratice.ipynb

Loads environment variables from a .env file and sets them for use in the application. This includes API keys for various services.

```python
import os
from dotenv import load_dotenv
load_dotenv()

GOOGLE_API_KEY=os.getenv("GOOGLE_API_KEY")
TAVILY_API_KEY=os.getenv("TAVILY_API_KEY")
GROQ_API_KEY=os.getenv("GROQ_API_KEY")
LANGCHAIN_API_KEY=os.getenv("LANGCHAIN_API_KEY")
LANGCHAIN_PROJECT=os.getenv("LANGCHAIN_PROJECT")
```

```python
os.environ["GOOGLE_API_KEY"] = GOOGLE_API_KEY
os.environ["TAVILY_API_KEY"] = TAVILY_API_KEY
os.environ["GROQ_API_KEY"]= GROQ_API_KEY
os.environ["LANGCHAIN_API_KEY"] = LANGCHAIN_API_KEY
os.environ["LANGCHAIN_TRACING_V2"] = "true"
os.environ["LANGCHAIN_ENDPOINT"] = "https://api.smith.langchain.com"
os.environ["LANGCHAIN_PROJECT"]=LANGCHAIN_PROJECT
```

--------------------------------

### Initialize Search Tool

Source: https://github.com/sunnysavita10/langgraph-end-to-end/blob/main/different_structure_pattern/React_agent_with_langgraph.ipynb

Initializes the DuckDuckGoSearchRun tool for web searches.

```Python
search = DuckDuckGoSearchRun()
```

--------------------------------

### Define Available Tools

Source: https://github.com/sunnysavita10/langgraph-end-to-end/blob/main/different_structure_pattern/React_agent_with_langgraph.ipynb

Creates a list of all available tools, including arithmetic functions and the search tool.

```Python
tools = [add, multiply, divide, search]
```

--------------------------------

### Initializing AgentState as an Empty Dictionary

Source: https://github.com/sunnysavita10/langgraph-end-to-end/blob/main/langgraph_from_scratch/scratch.ipynb

Initializes 'AgentState' as an empty dictionary.

```python
AgentState={}
```

--------------------------------

### Importing LLM

Source: https://github.com/sunnysavita10/langgraph-end-to-end/blob/main/multiagent_system/multiagent.ipynb

Imports the ChatGroq model for language generation.

```Python
from langchain_groq import ChatGroq
```

--------------------------------

### Initializing Tools

Source: https://github.com/sunnysavita10/langgraph-end-to-end/blob/main/multiagent_system/multiagent.ipynb

Initializes instances of the TavilySearchResults and PythonREPLTool for use in the agents.

```Python
tavily_tool = TavilySearchResults(max_results=5)

python_repl_tool = PythonREPLTool()
```

--------------------------------

### Example State for Addition

Source: https://github.com/sunnysavita10/langgraph-end-to-end/blob/main/multiagent_system/network_multiagent_system.ipynb

Provides an example state dictionary containing numbers to be used with the `add_numbers` function.

```Python
state={"num1":1, "num2":2}
```

--------------------------------

### Langchain PydanticOutputParser Initialization

Source: https://github.com/sunnysavita10/langgraph-end-to-end/blob/main/langgraph_from_scratch/scratch.ipynb

Initializes the PydanticOutputParser from Langchain, associating it with a Pydantic model for structured output parsing.

```python
from langchain.output_parsers import PydanticOutputParser
parser = PydanticOutputParser(pydantic_object=TopicSelectionParser)
```

--------------------------------

### System Prompt Output Example

Source: https://github.com/sunnysavita10/langgraph-end-to-end/blob/main/multiagent_system/research_analyst_multiagent.ipynb

The resulting system prompt string generated by the `make_system_prompt` function, including the base instructions and the specific role for the researcher agent.

```python
"You are a helpful AI assistant, collaborating with other assistants. Use the provided tools to progress towards answering the question. If you are unable to fully answer, that's OK, another assistant with different tools  will help where you left off. Execute what you can to make progress. If you or any of the other assistants have the final answer or deliverable, prefix your response with FINAL ANSWER so the team knows to stop.\nYou can only do research. You are working with a chart generator colleague."
```

--------------------------------

### Initializing AgentState Messages List

Source: https://github.com/sunnysavita10/langgraph-end-to-end/blob/main/langgraph_from_scratch/scratch.ipynb

Initializes the 'messages' key within 'AgentState' as an empty list.

```python
AgentState["messages"]=[]
```

--------------------------------

### Initialize StateGraph

Source: https://github.com/sunnysavita10/langgraph-end-to-end/blob/main/multiagent_system/supervisor_agent.ipynb

Initializes a StateGraph with the defined `State` class, preparing to build the workflow graph.

```Python
graph=StateGraph(State)
```

--------------------------------

### Compiling the LangGraph Application

Source: https://github.com/sunnysavita10/langgraph-end-to-end/blob/main/langgraph_from_scratch/scratch.ipynb

Compiles the defined LangGraph workflow into an executable application.

```python
app6 = workflow6.compile()
```

--------------------------------

### Agentic Prompt Example 1 (General Purpose)

Source: https://github.com/sunnysavita10/langgraph-end-to-end/blob/main/ReAct_Agent_From_Scratch/ReACt_Agent_From_Scratch_In_Python.ipynb

Defines a prompt for an agent that operates in a Thought, Action, PAUSE, Observation, Answer loop. It includes available tools like 'calculate', 'wikipedia', and 'simon_blog_search', along with an example session and handling for basic conversational inputs.

```python
prompt = """
You run in a loop of Thought, Action, PAUSE, Observation.
At the end of the loop your output an Answer.
Use Thought to describe your thoughts about the question you have been asked.
Use Action to run one of the actions available to you - then return PAUSE.
Observation will be the result of running those actions.


Your available actions are:
calculate:
  e.g. calculate: 4 * 7 / 3
Runs a calculation and returns the number - uses Python so be sure to use floating point
syntax if necessary

wikipedia:
  e.g. wikipedia: Django
Returns a summary from searching Wikipedia

simon_blog_search:
  e.g. simon_blog_search: Python
Search Simon's blog for that term

Example session:
Question: What is the capital of France?
Thought: I should look up France on Wikipedia
Action: wikipedia: France
PAUSE

You will be called again with this:
Observation: France is a country. The capital is Paris.

You then output:
Answer: The capital of France is Paris

Please Note: if you get basic conversation questions like "hi","hello","how are you?",\n
you have to answer "hi","hello","i am good".
"""
```

--------------------------------

### Initialize Python REPL Tool

Source: https://github.com/sunnysavita10/langgraph-end-to-end/blob/main/multiagent_system/supervisor_agent.ipynb

Initializes the PythonREPL tool, which allows the agent to execute Python code.

```Python
repl=PythonREPL()
```

--------------------------------

### Initializing LLM

Source: https://github.com/sunnysavita10/langgraph-end-to-end/blob/main/multiagent_system/multiagent.ipynb

Initializes the ChatGroq language model with a specific model name.

```Python
llm=ChatGroq(model="llama3-70b-8192")
```

--------------------------------

### Compile Graph

Source: https://github.com/sunnysavita10/langgraph-end-to-end/blob/main/multiagent_system/supervisor_agent.ipynb

Compiles the StateGraph into an executable application, making it ready for invocation.

```Python
app=graph.compile()
```

--------------------------------

### Get and Clean Model Response

Source: https://github.com/sunnysavita10/langgraph-end-to-end/blob/main/multiagent_system/supervisor_agent.ipynb

Invokes the ChatGroq model and then cleans the response content using the `clean_text` function.

```Python
response=groq_model.invoke("hi")
clean_text(response.content)
```

--------------------------------

### Chroma Vector Store and Retriever Initialization

Source: https://github.com/sunnysavita10/langgraph-end-to-end/blob/main/langgraph_from_scratch/scratch.ipynb

Initializes a Chroma vector store with documents and sets up a retriever for efficient searching. Assumes 'new_docs' and 'embeddings' are defined.

```python
db = Chroma.from_documents(new_docs, embeddings)
retriever = db.as_retriever(search_kwargs={"k": 3})
```

--------------------------------

### Run Python Code with REPL

Source: https://github.com/sunnysavita10/langgraph-end-to-end/blob/main/multiagent_system/supervisor_agent.ipynb

Executes the predefined Python code snippet using the PythonREPL tool.

```Python
repl.run(code)
```

--------------------------------

### Add Graph Edge

Source: https://github.com/sunnysavita10/langgraph-end-to-end/blob/main/multiagent_system/supervisor_agent.ipynb

Adds an edge from the START state to the supervisor node, defining the initial flow of the graph.

```Python
graph.add_edge(START,"supervisor")
```

--------------------------------

### Format Initial State Messages

Source: https://github.com/sunnysavita10/langgraph-end-to-end/blob/main/multiagent_system/supervisor_agent.ipynb

Formats the initial system prompt and state messages for the supervisor node.

```Python
[{"role": "system", "content": system_prompt},] + state["next"]
```

--------------------------------

### Get Tools from Toolkit

Source: https://github.com/sunnysavita10/langgraph-end-to-end/blob/main/agent_based_rag/sql_agent_with_langgraph.ipynb

Retrieves a list of available tools from the SQLDatabaseToolkit.

```python
tools=toolkit.get_tools()
```

--------------------------------

### Define System Message

Source: https://github.com/sunnysavita10/langgraph-end-to-end/blob/main/different_structure_pattern/React_agent_with_langgraph.ipynb

Defines the system message that guides the behavior of the language model, instructing it to use search and perform arithmetic.

```Python
# System message
sys_msg = SystemMessage(content="You are a helpful assistant tasked with using search and performing arithmetic on a set of inputs.")
```

--------------------------------

### YouTube Search Tool - Example 1

Source: https://github.com/sunnysavita10/langgraph-end-to-end/blob/main/Pre-requist_for_langgraph/Tools_and_agents.ipynb

Initializes and uses the YouTubeSearchTool to search for 'sunny savita' on YouTube.

```python
from langchain_community.tools import YouTubeSearchTool
tool2=YouTubeSearchTool()
tool2.run("sunny savita")
```

--------------------------------

### Importing Langchain Core Components

Source: https://github.com/sunnysavita10/langgraph-end-to-end/blob/main/langgraph_from_scratch/scratch.ipynb

Imports necessary components from langchain_core for output parsing, prompt templating, and runnable sequences.

```python
from langchain_core.output_parsers import StrOutputParser
from langchain_core.prompts import ChatPromptTemplate
from langchain_core.runnables import RunnablePassthrough
```

--------------------------------

### Invoke Custom Tool: get_word_length (Example 1)

Source: https://github.com/sunnysavita10/langgraph-end-to-end/blob/main/Pre-requist_for_langgraph/Tools_and_agents.ipynb

Invokes the custom 'get_word_length' tool with the input 'abc' to get the length of the word.

```python
get_word_length.invoke("abc")
```

--------------------------------

### Invoke Custom Tool: get_word_length (Example 2)

Source: https://github.com/sunnysavita10/langgraph-end-to-end/blob/main/Pre-requist_for_langgraph/Tools_and_agents.ipynb

Invokes the custom 'get_word_length' tool with the input 'sunny savita' to get the length of the string.

```python
get_word_length.invoke("sunny savita")
```

--------------------------------

### Initialize and Compile Simple LangGraph Workflow

Source: https://github.com/sunnysavita10/langgraph-end-to-end/blob/main/langgraph_from_scratch/scratch.ipynb

Initializes a LangGraph Graph, adds nodes 'function1' and 'function2', sets the entry point to 'function1' and the finish point to 'function2', and compiles the workflow.

```python
from langgraph.graph import Graph

#this is called a simple graph
#we have one more type of graph that is called stategraph
workflow1=Graph()

workflow1.add_node("function1", function1)

workflow1.add_node("function2",function2)

workflow1.add_edge("function1","function2")

workflow1.set_entry_point("function1")

workflow1.set_finish_point("function2")

app1=workflow1.compile()
```

--------------------------------

### Run Python Code with REPL

Source: https://github.com/sunnysavita10/langgraph-end-to-end/blob/main/multiagent_system/research_analyst_multiagent.ipynb

Executes the predefined Python code using the initialized PythonREPL tool.

```python
repl.run(code)
```

--------------------------------

### Initialize Tavily Search Tool

Source: https://github.com/sunnysavita10/langgraph-end-to-end/blob/main/multiagent_system/supervisor_agent.ipynb

Initializes the TavilySearchResults tool, which allows the agent to perform web searches.

```Python
tavaily_tool=TavilySearchResults()
```

--------------------------------

### Updated Tools List with Finance Tool

Source: https://github.com/sunnysavita10/langgraph-end-to-end/blob/main/different_structure_pattern/React_agent_with_langgraph.ipynb

Updates the list of available tools to include the get_stock_price function.

```Python
tools = [add, multiply, divide, search, get_stock_price]
```

--------------------------------

### Invoke Simple Workflow

Source: https://github.com/sunnysavita10/langgraph-end-to-end/blob/main/langgraph_from_scratch/scratch.ipynb

Invokes the compiled simple workflow (app1) with a string input 'sunny'.

```python
function1("sunny")
```

--------------------------------

### Visualize Simple Workflow Graph

Source: https://github.com/sunnysavita10/langgraph-end-to-end/blob/main/langgraph_from_scratch/scratch.ipynb

Displays the compiled simple workflow (app1) as a PNG image using Mermaid. Requires additional dependencies.

```python
from IPython.display import Image, display

try:
    display(Image(app1.get_graph().draw_mermaid_png()))
except Exception as e:
    # This requires some extra dependencies and is optional
    print(e)
```

--------------------------------

### Environment Setup and API Keys

Source: https://github.com/sunnysavita10/langgraph-end-to-end/blob/main/agent_based_rag/self_rag.ipynb

Loads environment variables using dotenv and sets necessary API keys and Langchain tracing configurations.

```python
import os
from dotenv import load_dotenv
load_dotenv()

GOOGLE_API_KEY=os.getenv("GOOGLE_API_KEY")
LANGCHAIN_API_KEY=os.getenv("LANGCHAIN_API_KEY")

os.environ["GOOGLE_API_KEY"] = GOOGLE_API_KEY
os.environ["LANGCHAIN_API_KEY"] = LANGCHAIN_API_KEY
os.environ["LANGCHAIN_TRACING_V2"] = "true"
os.environ["LANGCHAIN_ENDPOINT"] = "https://api.smith.langchain.com"
```

--------------------------------

### Initialize Wikipedia API Wrapper and Tool

Source: https://github.com/sunnysavita10/langgraph-end-to-end/blob/main/Pre-requist_for_langgraph/Pre_requist_Assistant_RAG_LCEL.ipynb

Sets up the Wikipedia API wrapper and creates a WikipediaQueryRun tool instance.

```python
api_wrapper=WikipediaAPIWrapper()
tool=WikipediaQueryRun(api_wrapper=api_wrapper)
```

--------------------------------

### Visualizing the Graph

Source: https://github.com/sunnysavita10/langgraph-end-to-end/blob/main/multiagent_system/multiagent.ipynb

Attempts to display a graphical representation of the compiled LangGraph workflow using Mermaid.

```Python
from IPython.display import Image, display

try:
    display(Image(graph.get_graph(xray=True).draw_mermaid_png()))
except Exception:
    # This requires some extra dependencies and is optional
    pass
```

--------------------------------

### Get Next Node Logic

Source: https://github.com/sunnysavita10/langgraph-end-to-end/blob/main/multiagent_system/research_analyst_multiagent.ipynb

Defines a function to determine the next node in the LangGraph workflow based on the last message's content. It checks for 'FINAL ANSWER' to transition to the END state or follows a specified 'goto' path.

```python
def get_next_node(last_message:BaseMessage, goto:str):
    if "FINAL ANSWER" in last_message.content:
        # Any agent decided the work is done
        return END
    return goto
```

--------------------------------

### Custom Tool: Get Word Length

Source: https://github.com/sunnysavita10/langgraph-end-to-end/blob/main/Pre-requist_for_langgraph/agents_pratice.ipynb

Defines a custom tool using the @tool decorator to calculate the length of a given word. It includes a docstring for description and type hints for parameters and return values.

```python
from langchain.agents import tool
@tool
def get_word_length(word: str) -> int:
    """Returns the length of a word."""
    return len(word)
```

```python
get_word_length.invoke("abc")
```

--------------------------------

### Importing Tools

Source: https://github.com/sunnysavita10/langgraph-end-to-end/blob/main/multiagent_system/multiagent.ipynb

Imports necessary tools for search and Python execution, including TavilySearchResults and PythonREPLTool from Langchain.

```Python
from typing import Annotated
from langchain_community.tools.tavily_search import TavilySearchResults

from langchain_core.tools import Tool
from langchain_experimental.utilities import PythonREPL
from langchain_experimental.tools import PythonREPLTool
```

--------------------------------

### Initialize State Dictionary

Source: https://github.com/sunnysavita10/langgraph-end-to-end/blob/main/multiagent_system/research_analyst_multiagent.ipynb

Initializes a simple state dictionary with a 'message' key containing a list of strings.

```python
state={"message":["hi","hello"]}
```

--------------------------------

### Invoke Python REPL Tool

Source: https://github.com/sunnysavita10/langgraph-end-to-end/blob/main/multiagent_system/supervisor_agent.ipynb

Invokes the `python_repl_tool` with the predefined Python code snippet and prints the result.

```Python
print(python_repl_tool.invoke(code))
```

--------------------------------

### Visualize Token Counter Workflow Graph

Source: https://github.com/sunnysavita10/langgraph-end-to-end/blob/main/langgraph_from_scratch/scratch.ipynb

Displays the compiled token counter workflow (app3) as a PNG image using Mermaid. Requires additional dependencies.

```python
from IPython.display import Image, display

try:
    display(Image(app3.get_graph().draw_mermaid_png()))
except Exception as e:
    # This requires some extra dependencies and is optional
    print(e)
```

--------------------------------

### Invoke Compiled Simple Workflow

Source: https://github.com/sunnysavita10/langgraph-end-to-end/blob/main/langgraph_from_scratch/scratch.ipynb

Invokes the compiled simple workflow (app1) with the input string 'hi this is sunny '.

```python
app1.invoke("hi this is sunny ")
```

--------------------------------

### Initialize and Compile Token Counter Workflow

Source: https://github.com/sunnysavita10/langgraph-end-to-end/blob/main/langgraph_from_scratch/scratch.ipynb

Initializes a LangGraph Graph, adds nodes 'llm' and 'token_counter' (using function1 and function3), sets entry/finish points, and compiles the workflow.

```python
workflow3=Graph()
workflow3.add_node("llm",function1)
workflow3.add_node("token_counter",function3)
workflow3.add_edge("llm","token_counter")
workflow3.set_entry_point("llm")
workflow3.set_finish_point("token_counter")
app3=workflow3.compile()
```

--------------------------------

### Invoke LLM-Integrated Workflow

Source: https://github.com/sunnysavita10/langgraph-end-to-end/blob/main/langgraph_from_scratch/scratch.ipynb

Invokes the compiled LLM-integrated workflow (app2) with a question about the first Indian prime minister.

```python
app2.invoke("what is a name of first indian prime minister?")
```

--------------------------------

### Operator Subtraction Example

Source: https://github.com/sunnysavita10/langgraph-end-to-end/blob/main/langgraph_from_scratch/scratch.ipynb

Demonstrates the use of the operator.sub function to perform subtraction.

```python
operator.sub(10, 15)
```

--------------------------------

### Visualize LLM-Integrated Workflow Graph

Source: https://github.com/sunnysavita10/langgraph-end-to-end/blob/main/langgraph_from_scratch/scratch.ipynb

Displays the compiled LLM-integrated workflow (app2) as a PNG image using Mermaid. Requires additional dependencies.

```python
from IPython.display import Image, display

try:
    display(Image(app2.get_graph().draw_mermaid_png()))
except Exception as e:
    # This requires some extra dependencies and is optional
    print(e)
```

--------------------------------

### Importing LangGraph and Core Components

Source: https://github.com/sunnysavita10/langgraph-end-to-end/blob/main/langgraph_from_scratch/scratch.ipynb

Imports necessary modules from langchain_core for tools, function calling, and message handling, along with the StateGraph and END from langgraph.

```python
import json
from langchain_core.tools import tool
from langchain_core.utils.function_calling import convert_to_openai_tool
```

--------------------------------

### Invoke Get Schema Tool

Source: https://github.com/sunnysavita10/langgraph-end-to-end/blob/main/agent_based_rag/sql_agent_with_langgraph.ipynb

Invokes the 'sql_db_schema' tool to get the schema for the 'employees' table.

```python
print(get_schema_tool.invoke("employees"))
```

--------------------------------

### Environment Variable Setup

Source: https://github.com/sunnysavita10/langgraph-end-to-end/blob/main/Pre-requist_for_langgraph/Tools_and_agents.ipynb

Loads environment variables from a .env file and sets them for use in the application, including API keys for Google, Tavily, Groq, and Langchain, along with Langchain tracing configurations.

```python
import os
from dotenv import load_dotenv
load_dotenv()

GOOGLE_API_KEY=os.getenv("GOOGLE_API_KEY")
TAVILY_API_KEY=os.getenv("TAVILY_API_KEY")
GROQ_API_KEY=os.getenv("GROQ_API_KEY")
LANGCHAIN_API_KEY=os.getenv("LANGCHAIN_API_KEY")
LANGCHAIN_PROJECT=os.getenv("LANGCHAIN_PROJECT")
os.environ["GOOGLE_API_KEY"] = GOOGLE_API_KEY
os.environ["TAVILY_API_KEY"] = TAVILY_API_KEY
os.environ["GROQ_API_KEY"]= GROQ_API_KEY
os.environ["LANGCHAIN_API_KEY"] = LANGCHAIN_API_KEY
os.environ["LANGCHAIN_TRACING_V2"] = "true"
os.environ["LANGCHAIN_ENDPOINT"] = "https://api.smith.langchain.com"
os.environ["LANGCHAIN_PROJECT"]=LANGCHAIN_PROJECT
```

--------------------------------

### Workflow Initial Edge

Source: https://github.com/sunnysavita10/langgraph-end-to-end/blob/main/agent_based_rag/agentic_rag.ipynb

Adds an initial edge to the workflow, starting from START and pointing to the 'My_Ai_Assistant' node.

```python
workflow.add_edge(START,"My_Ai_Assistant")
```

--------------------------------

### Environment Variable Setup

Source: https://github.com/sunnysavita10/langgraph-end-to-end/blob/main/ReAct_Agent_From_Scratch/ReACt_Agent_From_Scratch_In_Python.ipynb

Loads environment variables from a .env file and sets them for use in the application, including API keys for Google, Groq, and LangChain, along with LangChain tracing configurations.

```python
import os
from dotenv import load_dotenv
load_dotenv()


GOOGLE_API_KEY=os.getenv("GOOGLE_API_KEY")
GROQ_API_KEY=os.getenv("GROQ_API_KEY")
LANGCHAIN_API_KEY=os.getenv("LANGCHAIN_API_KEY")
LANGCHAIN_PROJECT=os.getenv("LANGCHAIN_PROJECT")


os.environ["GOOGLE_API_KEY"] = GOOGLE_API_KEY
os.environ["GROQ_API_KEY"]= GROQ_API_KEY
os.environ["LANGCHAIN_API_KEY"] = LANGCHAIN_API_KEY
os.environ["LANGCHAIN_TRACING_V2"] = "true"
os.environ["LANGCHAIN_ENDPOINT"] = "https://api.smith.langchain.com"
os.environ["LANGCHAIN_PROJECT"]=LANGCHAIN_PROJECT
```

--------------------------------

### Initialize DuckDuckGo Search Tool

Source: https://github.com/sunnysavita10/langgraph-end-to-end/blob/main/multiagent_system/research_analyst_multiagent.ipynb

Initializes the DuckDuckGoSearchRun tool, which will be used by the researcher agent to perform web searches.

```python
search_tool=DuckDuckGoSearchRun()
```

--------------------------------

### Initialize and Compile LLM-Integrated Workflow

Source: https://github.com/sunnysavita10/langgraph-end-to-end/blob/main/langgraph_from_scratch/scratch.ipynb

Initializes a LangGraph Graph, adds nodes 'llm' and 'upper_string' (using provided function1 and function2), sets entry/finish points, and compiles the workflow.

```python
from langgraph.graph import Graph
workflow2=Graph()
workflow2.add_node("llm",function1)
workflow2.add_node("upper_string",function2)
workflow2.add_edge("llm","upper_string")
workflow2.set_entry_point("llm")
workflow2.set_finish_point("upper_string")
app2=workflow2.compile()
```

--------------------------------

### Building the LangGraph Workflow

Source: https://github.com/sunnysavita10/langgraph-end-to-end/blob/main/multiagent_system/multiagent.ipynb

Constructs the stateful graph, adds nodes for the supervisor and agents, defines edges, and sets up conditional transitions based on the supervisor's output.

```Python
workflow = StateGraph(AgentState)
workflow.add_node("Researcher", research_node)
workflow.add_node("Coder", code_node)
workflow.add_node("supervisor", supervisor_agent)
for member in members:
    workflow.add_edge(member, "supervisor")
conditional_map = {k: k for k in members}
conditional_map["FINISH"] = END
workflow.add_conditional_edges("supervisor", lambda x: x["next"], conditional_map)
workflow.add_edge(START, "supervisor")
graph = workflow.compile()
```

--------------------------------

### Pydantic Model Field Example

Source: https://github.com/sunnysavita10/langgraph-end-to-end/blob/main/langgraph_from_scratch/scratch.ipynb

Illustrates a single field definition within a Pydantic model, specifying its type and description.

```python
Topic: str = Field(description='Selected Topic')
```

--------------------------------

### Supervisor Options

Source: https://github.com/sunnysavita10/langgraph-end-to-end/blob/main/multiagent_system/multiagent.ipynb

Creates a list of possible next actions for the supervisor, including FINISH and the names of the worker agents.

```Python
options = ["FINISH"] + members

options=tuple(options)
```

--------------------------------

### Set Initial Edge

Source: https://github.com/sunnysavita10/langgraph-end-to-end/blob/main/multiagent_system/network_multiagent_system.ipynb

Defines the starting point of the graph, setting the initial transition from the `START` state to the 'additional_expert' node.

```Python
graph.add_edge(START, "additional_expert")
```

--------------------------------

### Displaying Graph Visualization

Source: https://github.com/sunnysavita10/langgraph-end-to-end/blob/main/langgraph_from_scratch/scratch.ipynb

Attempts to display a visual representation of the compiled Langchain graph using Mermaid. Requires 'IPython.display' and potentially additional dependencies for PNG generation.

```python
from IPython.display import Image, display

try:
    display(Image(app4.get_graph().draw_mermaid_png()))
except Exception as e:
    # This requires some extra dependencies and is optional
    print(e)
```

--------------------------------

### Visualizing the Graph (Mermaid)

Source: https://github.com/sunnysavita10/langgraph-end-to-end/blob/main/langgraph_from_scratch/scratch.ipynb

Attempts to display a visual representation of the compiled graph using Mermaid. This requires additional dependencies and might fail if not set up.

```python
from IPython.display import Image, display

try:
    display(Image(app6.get_graph().draw_mermaid_png()))
except Exception as e:
    # This requires some extra dependencies and is optional
    print(e)
```

--------------------------------

### Example State Initialization

Source: https://github.com/sunnysavita10/langgraph-end-to-end/blob/main/langgraph_from_scratch/langgraph_scratch.ipynb

Demonstrates how to initialize the state for the LangGraph workflow, specifically setting the 'messages' field with a sample user query.

```python
state={"messages": ["Tell me about India's Industrial Growth"]}
```

--------------------------------

### Pydantic Data Validation - Invalid Input

Source: https://github.com/sunnysavita10/langgraph-end-to-end/blob/main/langgraph_from_scratch/scratch.ipynb

Shows how Pydantic handles invalid data by raising a ValidationError. This example uses incorrect data types for the 'Reasoning' field.

```python
# Invalid data (Reasoning is not a string)
invalid_data = {
    "Topic": "Artificial Intelligence",
    "Reasoning": 12345  # Invalid type, should be a string
}

# This will raise a validation error
try:
    topic_selection = TopicSelectionParser(**invalid_data)
    print(topic_selection.Topic)  # Output: Artificial Intelligence
    print(topic_selection.Reasoning)  # Output: It's a rapidly growing field with many advancements.
except ValidationError as e:
    print(e)  # This will print a detailed error message about the invalid field
```

--------------------------------

### Pydantic Data Validation - Valid Input

Source: https://github.com/sunnysavita10/langgraph-end-to-end/blob/main/langgraph_from_scratch/scratch.ipynb

Demonstrates how to use a Pydantic model to validate data. This example shows a successful parsing of valid data, printing the extracted Topic and Reasoning.

```python
from pydantic import ValidationError

# Valid data
data = {
    "Topic": "Artificial Intelligence",
    "Reasoning": "It's a rapidly growing field with many advancements."
}

# Parsing and validating the data using the Pydantic model
try:
    topic_selection = TopicSelectionParser(**data)
    print(topic_selection.Topic)  # Output: Artificial Intelligence
    print(topic_selection.Reasoning)  # Output: It's a rapidly growing field with many advancements.
except ValidationError as e:
    print(e)
```

--------------------------------

### Run Agent with a Question

Source: https://github.com/sunnysavita10/langgraph-end-to-end/blob/main/Pre-requist_for_langgraph/Pre_requist_Assistant_RAG_LCEL.ipynb

Executes the initialized agent to answer a question about India's GDP.

```python
agent.run("What is current GDP of India?")
```

--------------------------------

### Agentic Prompt Example 2 (Fitness Focused)

Source: https://github.com/sunnysavita10/langgraph-end-to-end/blob/main/ReAct_Agent_From_Scratch/ReACt_Agent_From_Scratch_In_Python.ipynb

Defines a prompt for a fitness-focused agent operating in a Thought, Action, PAUSE, Observation, Answer loop. It specifies available tools related to fitness and health, such as 'calculate', 'fitness_wiki', 'exercise_plan', and 'nutrition_info', and provides an example session.

```python
prompt = """You run in a loop of Thought, Action, PAUSE, Observation.
At the end of the loop, you output an Answer related to fitness, health, or exercise.
Use Thought to describe your thoughts about the question you have been asked.
Use Action to run one of the actions available to you - then return PAUSE.
Observation will be the result of running those actions.

Your available actions are:

calculate:
  e.g. calculate: 1800 * 0.2
Runs a calculation (e.g., calorie intake, BMI, workout progress) and returns the result.

fitness_wiki:
  e.g. fitness_wiki: Benefits of Cardio
Returns a summary of fitness-related information from a fitness knowledge base (Wikipedia or similar).

exercise_plan:
  e.g. exercise_plan: Beginner full-body workout
Returns a recommended workout plan based on the type of exercise or user level.

nutrition_info:
  e.g. nutrition_info: Protein sources for vegetarians
Looks up nutritional information or suggestions for diets.

Example session:
Question: What are the benefits of cardio exercises?
Thought: I should look up information about the benefits of cardio exercises.
Action: fitness_wiki: Benefits of Cardio
PAUSE

You will be called again with this:

Observation: Cardio exercises improve cardiovascular health, increase lung capacity, and aid in weight loss.

You then output:

Answer: Cardio exercises improve cardiovascular health, increase lung capacity, and help with weight loss.
"""
```

--------------------------------

### Import LangChain Core and Operator Modules

Source: https://github.com/sunnysavita10/langgraph-end-to-end/blob/main/langgraph_from_scratch/scratch.ipynb

Imports necessary components from LangChain core for message handling and the operator module for arithmetic operations.

```python
from typing import TypedDict, Annotated, Sequence
import operator
from langchain_core.messages import BaseMessage
from langchain.prompts import PromptTemplate
```

--------------------------------

### List Available Tools

Source: https://github.com/sunnysavita10/langgraph-end-to-end/blob/main/agent_based_rag/sql_agent_with_langgraph.ipynb

Prints the list of tools generated by the SQLDatabaseToolkit.

```python
tools
```

--------------------------------

### Displaying AgentState After Appending

Source: https://github.com/sunnysavita10/langgraph-end-to-end/blob/main/langgraph_from_scratch/scratch.ipynb

Prints the current state of the 'AgentState' dictionary.

```python
AgentState
```

--------------------------------

### Accessing an Empty Dictionary

Source: https://github.com/sunnysavita10/langgraph-end-to-end/blob/main/langgraph_from_scratch/scratch.ipynb

Prints the current content of the 'mydict' dictionary.

```python
mydict
```

--------------------------------

### Define Agent Members

Source: https://github.com/sunnysavita10/langgraph-end-to-end/blob/main/multiagent_system/supervisor_agent.ipynb

Defines a list of members (agents) that will participate in the workflow.

```Python
members=["researcher","coder"]
options=members+["FINISH"]
options
```

--------------------------------

### Defining Agent Members

Source: https://github.com/sunnysavita10/langgraph-end-to-end/blob/main/multiagent_system/multiagent.ipynb

Defines a list of agent names that will participate in the workflow.

```Python
members = ["Researcher", "Coder"]
```

--------------------------------

### Initialize ChatGroq Model

Source: https://github.com/sunnysavita10/langgraph-end-to-end/blob/main/multiagent_system/supervisor_agent.ipynb

Initializes the ChatGroq language model with a specific model name and API key. This model will be used for generating responses and controlling agent behavior.

```Python
from langchain_groq import ChatGroq
groq_model=ChatGroq(model="deepseek-r1-distill-llama-70b",api_key="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")
```

--------------------------------

### Importing Prompt and Pydantic Components

Source: https://github.com/sunnysavita10/langgraph-end-to-end/blob/main/multiagent_system/multiagent.ipynb

Imports necessary components for creating prompts and defining data models, including ChatPromptTemplate, BaseModel, and Literal.

```Python
from langchain_core.prompts import ChatPromptTemplate, MessagesPlaceholder
from pydantic import BaseModel
from typing import Literal
```

--------------------------------

### Graph Visualization

Source: https://github.com/sunnysavita10/langgraph-end-to-end/blob/main/langgraph_from_scratch/scratch.ipynb

Displays the compiled LangGraph workflow as a PNG image using Mermaid. This requires additional dependencies and is an optional step for visualizing the graph structure.

```python
from IPython.display import Image, display

try:
    display(Image(app5.get_graph().draw_mermaid_png()))
except Exception as e:
    # This requires some extra dependencies and is optional
    print(e)
```

--------------------------------

### Import Necessary Libraries

Source: https://github.com/sunnysavita10/langgraph-end-to-end/blob/main/multiagent_system/research_analyst_multiagent.ipynb

Imports core components from LangGraph, Langchain, and other libraries required for building the agent workflow, including tools for search, LLM interaction, and environment variable loading.

```python
from typing_extensions import Literal
from langchain_core.tools import tool
from langchain_groq import ChatGroq
from langgraph.graph import MessagesState, StateGraph,START,END
from langgraph.types import Command
from dotenv import load_dotenv
from IPython.display import Image, display
from langchain_openai import ChatOpenAI
from langchain_core.messages import BaseMessage, HumanMessage
from langgraph.prebuilt import create_react_agent
from typing import Annotated
from langchain_experimental.utilities import PythonREPL
from langchain_community.tools import DuckDuckGoSearchRun
```

--------------------------------

### Pydantic Output Parsing with LangChain

Source: https://github.com/sunnysavita10/langgraph-end-to-end/blob/main/langgraph_from_scratch/scratch.ipynb

Demonstrates parsing model output using PydanticOutputParser and a custom Pydantic model. It highlights the correct way to instantiate and use the parser with dictionary outputs.

```python
from langchain_community.document_loaders import TextLoader, DirectoryLoader
from langchain_community.vectorstores import Chroma
from langchain.text_splitter import RecursiveCharacterTextSplitter
from pydantic import BaseModel , Field

# Pydantic model for structured output
class TopicSelectionParser(BaseModel):
    Topic: str = Field(description='Selected Topic')
    Reasoning: str = Field(description='Reasoning behind topic selection')

# Example of parsing output (assuming 'output' is a dictionary)
try:
    # Instead of directly parsing, create an instance of TopicSelectionParser
    parsed_result = TopicSelectionParser(**output)
    # Alternatively, if you prefer to use PydanticOutputParser:
    # parsed_result = parser.parse(output)  # This will not work since output is a dict, not a string

    # Display the parsed result
    print(parsed_result)

except Exception as e:
    print(f"Error: {e}")
```

--------------------------------

### Accessing Updated Dictionary

Source: https://github.com/sunnysavita10/langgraph-end-to-end/blob/main/langgraph_from_scratch/scratch.ipynb

Prints the current content of the 'mydict' dictionary after modification.

```python
mydict
```

--------------------------------

### Initializing Groq Chat LLM

Source: https://github.com/sunnysavita10/langgraph-end-to-end/blob/main/Pre-requist_for_langgraph/Pre_requist_Assistant_RAG_LCEL.ipynb

Initializes a chat LLM using the ChatGroq integration, specifying the 'Gemma2-9b-It' model. It also imports the os module, which might be used for accessing API keys.

```python
from langchain_groq import ChatGroq
import osllm=ChatGroq(model_name="Gemma2-9b-It")
```

--------------------------------

### Concatenate Workflow Function Outputs

Source: https://github.com/sunnysavita10/langgraph-end-to-end/blob/main/langgraph_from_scratch/scratch.ipynb

Concatenates the outputs of function1 and function2 with a space in between.

```python
function1("sunny")+ " "+function2("savita")
```

--------------------------------

### Invoke Simple Workflow Function 2

Source: https://github.com/sunnysavita10/langgraph-end-to-end/blob/main/langgraph_from_scratch/scratch.ipynb

Invokes function2 with the input 'savita'.

```python
function2("savita")
```

--------------------------------

### Initialize and Use Tavily Search Tool

Source: https://github.com/sunnysavita10/langgraph-end-to-end/blob/main/Pre-requist_for_langgraph/Pre_requist_Assistant_RAG_LCEL.ipynb

Imports and initializes the TavilySearchResults tool for performing searches.

```python
from langchain_community.tools.tavily_search import TavilySearchResults

tool3=TavilySearchResults()
```

--------------------------------

### Add Graph Nodes

Source: https://github.com/sunnysavita10/langgraph-end-to-end/blob/main/multiagent_system/supervisor_agent.ipynb

Adds the defined supervisor, researcher, and coder nodes to the StateGraph.

```Python
graph.add_node("supervisor",supervisor_node)
graph.add_node("researcher", research_node)
graph.add_node("coder", code_node)
```

--------------------------------

### Converting Tool to OpenAI Format

Source: https://github.com/sunnysavita10/langgraph-end-to-end/blob/main/langgraph_from_scratch/scratch.ipynb

Converts the defined 'multiply' tool into a format compatible with OpenAI's function calling specifications using 'convert_to_openai_tool'.

```python
tools=[convert_to_openai_tool(multiply)]
```

--------------------------------

### Chatbot Initialization

Source: https://github.com/sunnysavita10/langgraph-end-to-end/blob/main/ReAct_Agent_From_Scratch/ReACt_Agent_From_Scratch_In_Python.ipynb

Instantiates the `Chatbot` class with a system message, setting up the chatbot's persona.

```python
bot=Chatbot(system="you are helpful assistant")
```

--------------------------------

### Invoke Tavily Search Tool

Source: https://github.com/sunnysavita10/langgraph-end-to-end/blob/main/multiagent_system/supervisor_agent.ipynb

Invokes the TavilySearchResults tool to search for the definition of GDP.

```Python
tavaily_tool.invoke("what is a gdp?")
```

--------------------------------

### Importing Message Types

Source: https://github.com/sunnysavita10/langgraph-end-to-end/blob/main/multiagent_system/multiagent.ipynb

Imports HumanMessage for representing user input in the message history.

```Python
from langchain_core.messages import HumanMessage
```

--------------------------------

### Print Enhanced Response Messages

Source: https://github.com/sunnysavita10/langgraph-end-to-end/blob/main/different_structure_pattern/React_agent_with_langgraph.ipynb

Iterates through and prints the messages from the response of the enhanced LangGraph.

```Python
for m in response['messages']:
    m.pretty_print()
```

--------------------------------

### Import and Use YouTube Search Tool

Source: https://github.com/sunnysavita10/langgraph-end-to-end/blob/main/Pre-requist_for_langgraph/Pre_requist_Assistant_RAG_LCEL.ipynb

Imports the YouTubeSearchTool and demonstrates its usage for searching videos.

```python
from langchain_community.tools import YouTubeSearchTool

tool2=YouTubeSearchTool()

tool2.name
tool2.run("sunny savita")
```

--------------------------------

### Print Second Response Messages

Source: https://github.com/sunnysavita10/langgraph-end-to-end/blob/main/different_structure_pattern/React_agent_with_langgraph.ipynb

Iterates through the messages in the second response from the graph and prints them.

```Python
for m in messages['messages']:
    m.pretty_print()
```

--------------------------------

### Initialize Language Model

Source: https://github.com/sunnysavita10/langgraph-end-to-end/blob/main/different_structure_pattern/React_agent_with_langgraph.ipynb

Initializes the ChatGroq language model with the specified model name.

```Python
from langchain_groq import ChatGroq
llm=ChatGroq(model_name="Gemma2-9b-It")
```

--------------------------------

### Graph Construction and Edge Definition

Source: https://github.com/sunnysavita10/langgraph-end-to-end/blob/main/langgraph_from_scratch/scratch.ipynb

Constructs the LangGraph workflow by creating a StateGraph, adding nodes for 'agent' and 'tool', setting an entry point, and defining edges including a conditional edge.

```python
from langgraph.graph import StateGraph,END
workflow6 = StateGraph(AgentState) ### StateGraph with AgentState
workflow6.add_node("agent", invoke_model)
workflow6.add_node("tool", invoke_tool)
workflow6.add_edge("tool", END)
workflow6.set_entry_point("agent")
```

--------------------------------

### Get Database Connection Object

Source: https://github.com/sunnysavita10/langgraph-end-to-end/blob/main/agent_based_rag/sql_agent_with_langgraph.ipynb

Retrieves the connection object for the SQLite database.

```python
connection
```

--------------------------------

### Get Tool Name from Details

Source: https://github.com/sunnysavita10/langgraph-end-to-end/blob/main/different_structure_pattern/human_in_loop.ipynb

Extracts the name of the tool from the tool details.

```python
tool_details[0]["function"]["name"]
```

--------------------------------

### Load and Initialize ReAct Agent

Source: https://github.com/sunnysavita10/langgraph-end-to-end/blob/main/Pre-requist_for_langgraph/Pre_requist_Assistant_RAG_LCEL.ipynb

Loads tools (like Wikipedia) and initializes a ReAct agent for task execution.

```python
from langchain.agents import AgentType
from langchain.agents import load_tools 
from langchain.agents import initialize_agent

tool=load_tools(["wikipedia"],llm=llm)
agent=initialize_agent(tool,llm,agent=AgentType.ZERO_SHOT_REACT_DESCRIPTION,verbose=True)
```

--------------------------------

### Accessing TypedDict Field 'age'

Source: https://github.com/sunnysavita10/langgraph-end-to-end/blob/main/langgraph_from_scratch/scratch.ipynb

Demonstrates accessing the 'age' field from a TypedDict instance.

```python
person["age"]
```
Tokens:
Raw