The Python Tutorials Blog

Building a MySQL Agent in Python LangGraph Framework

Fri, 04 Jul 2025 00:00:00 -0400

Large language models (LLMs) have revolutionized the way people interact with software applications. You can use natural language commands to instruct AI agents to perform specific tasks.

One of the most useful LLM applications is interacting with a database using natural language, as it allows non-technical users to issue commands and retrieve data from databases, which would otherwise require some database expertise.

In this tutorial, you’ll see how to develop a MySQL AI agent using the OpenAI GPT-4o model that allows you to interact with a MySQL database using natural language. We will utilize the LangGraph orchestration framework to develop the AI agent.

Installing and Importing Required Libraries

You need to install the following libraries to run scripts in this tutorial.

#LangGraph + LangChain + OpenAI + MySQL driver + SQLAlchemy
%pip install -U langgraph langgraph-prebuilt langchain_community "langchain[openai]" pymysql sqlalchemy

The script below imports the required libraries.

from langchain_community.utilities import SQLDatabase
from langchain_openai import ChatOpenAI
from langchain_community.agent_toolkits import SQLDatabaseToolkit
from langgraph.prebuilt import create_react_agent
from IPython.display import Image, display
from langchain_core.runnables.graph import CurveStyle, MermaidDrawMethod, NodeStyles

Creating a MySQL Connection and Retrieving DB Information

To execute sample codes, we store the dummy employees database on a local MySQL server.

The following script uses the LangChain SQLDatabase utility to retrieve information from the MySQL database.

We will pass this information on to our AI agent, which will then generate accurate MySQL queries based on natural language commands.

##database link
##https://github.com/datacharmer/test_db

db_uri = "mysql+pymysql://root:abcd123@localhost:3306/employees"

db = SQLDatabase.from_uri(db_uri)
print("Dialect:", db.dialect)
print("Tables :", db.get_usable_table_names()[:6], "...")

Output:

Dialect: mysql
Tables : ['departments', 'dept_emp', 'dept_manager', 'employees', 'salaries', 'titles'] ...

Importing LangChain Database Tools

LangChain’s SQLDatabaseToolkit contains tools that allow you to generate a SQL query from natural language, verify the query’s accuracy, retrieve the database schema, and list database tables. These tools are used by LangGraph AI agents while retrieving information from a database.

The following script imports these tools into your application and prints their descriptions. Notice the placeholder below where you’ll need to enter your own OpenAI API key.

openai_api_key = "YOUR_OPENAI_API_KEY"
llm = ChatOpenAI(api_key = openai_api_key,
             temperature = 0,
            model_name = "gpt-4o")

toolkit = SQLDatabaseToolkit(db=db, llm=llm)

tools = toolkit.get_tools()

for tool in tools:
    print(f"{tool.name}: {tool.description}\n")

Output:

Creating MySQL Agent using LangGraph Default ReAct Agent

Creating an agent in LangGraph is straightforward. You can use LangGraph’s default ReAct agent, which, given an input and a prompt, automatically selects and executes various tools to generate the best possible response.

The following script creates a MySQL ReAct agent in LangGraph. The prompt informs the Agent of the type of input it will receive and the steps it should take to generate a response.

from langgraph.prebuilt import create_react_agent

system_prompt = """
You are an agent designed to interact with a SQL database.
Given an input question, create a syntactically correct {dialect} query to run,
then look at the results of the query and return the answer. Unless the user
specifies a specific number of examples they wish to obtain, always limit your
query to at most {top_k} results.

You can order the results by a relevant column to return the most interesting
examples in the database. Never query for all the columns from a specific table,
only ask for the relevant columns given the question.

You MUST double check your query before executing it. If you get an error while
executing a query, rewrite the query and try again.

DO NOT make any DML statements (INSERT, UPDATE, DELETE, DROP etc.) to the
database.

To start you should ALWAYS look at the tables in the database to see what you
can query. Do NOT skip this step.

Then you should query the schema of the most relevant tables.
""".format(
    dialect=db.dialect,
    top_k=5,
)

agent = create_react_agent(
    llm,
    tools,
    prompt=system_prompt,
)

display(Image(agent.get_graph().draw_mermaid_png()))

Output:

Let’s test the AI agent by asking a question. The typo (employes) in the question below is intentional. The output will show that our MySQL agent is capable of comprehending natural language queries, even if they contain minor errors.

question = "Give me the names of the top three employes with highest salaries"

for step in Agent.stream(
    {"messages": [{"role": "user", "content": question}]},
    stream_mode="values",
):
    step["messages"][-1].pretty_print()

Output:

The following output displays the flow of messages and corresponding tool calls executed by the MySQL agent to generate the final response.

The agent first called the sql_db_list_tables tools as mentioned in the prompt, which returned all the table names. It then called the sql_db_schema tool to retrieve the scheme of the relevant tables, which are employees, and salaries tables in our case. The agent generates a query and then calls the sql_db_query_checker tool to see if the query is correct. Finally, it calls the sql_db_query tool to execute the query. You can see the names of the top three employees with highest salaries.

================================ Human Message =================================

Give me the names of the top three employes with highest salaries
================================== Ai Message ==================================
Tool Calls:
  sql_db_list_tables (call_bzgBY6HeV69vEhUWyRdRjHHU)
 Call ID: call_bzgBY6HeV69vEhUWyRdRjHHU
  Args:
================================= Tool Message =================================
Name: sql_db_list_tables

departments, dept_emp, dept_manager, employees, salaries, titles
================================== Ai Message ==================================
Tool Calls:
  sql_db_schema (call_TcCnyCqrR6elKtSSmm2WhsNc)
 Call ID: call_TcCnyCqrR6elKtSSmm2WhsNc
  Args:
    table_names: employees, salaries
================================= Tool Message =================================
Name: sql_db_schema


CREATE TABLE employees (
	emp_no INTEGER NOT NULL,
	birth_date DATE NOT NULL,
	first_name VARCHAR(14) NOT NULL,
	last_name VARCHAR(16) NOT NULL,
	gender ENUM('M','F') NOT NULL,
	hire_date DATE NOT NULL,
	PRIMARY KEY (emp_no)
)DEFAULT CHARSET=utf8mb4 COLLATE utf8mb4_0900_ai_ci ENGINE=InnoDB

/*
3 rows from employees table:
emp_no	birth_date	first_name	last_name	gender	hire_date
10001	1953-09-02	Georgi	Facello	M	1986-06-26
10002	1964-06-02	Bezalel	Simmel	F	1985-11-21
10003	1959-12-03	Parto	Bamford	M	1986-08-28
*/


CREATE TABLE salaries (
	emp_no INTEGER NOT NULL,
	salary INTEGER NOT NULL,
	from_date DATE NOT NULL,
	to_date DATE NOT NULL,
	PRIMARY KEY (emp_no, from_date),
	CONSTRAINT salaries_ibfk_1 FOREIGN KEY(emp_no) REFERENCES employees (emp_no) ON DELETE CASCADE
)DEFAULT CHARSET=utf8mb4 COLLATE utf8mb4_0900_ai_ci ENGINE=InnoDB

/*
3 rows from salaries table:
emp_no	salary	from_date	to_date
10001	60117	1986-06-26	1987-06-26
10001	62102	1987-06-26	1988-06-25
10001	66074	1988-06-25	1989-06-25
*/
================================== Ai Message ==================================
Tool Calls:
  sql_db_query_checker (call_F2w7ubGL6p8yNjyzuxAps09Z)
 Call ID: call_F2w7ubGL6p8yNjyzuxAps09Z
  Args:
    query: SELECT e.first_name, e.last_name, s.salary FROM employees e JOIN salaries s ON e.emp_no = s.emp_no ORDER BY s.salary DESC LIMIT 3;
================================= Tool Message =================================
Name: sql_db_query_checker

```sql
SELECT e.first_name, e.last_name, s.salary FROM employees e JOIN salaries s ON e.emp_no = s.emp_no ORDER BY s.salary DESC LIMIT 3;
```
================================== Ai Message ==================================
Tool Calls:
  sql_db_query (call_5GYtmevKF2TyQJXcGfEH8ZzM)
 Call ID: call_5GYtmevKF2TyQJXcGfEH8ZzM
  Args:
    query: SELECT e.first_name, e.last_name, s.salary FROM employees e JOIN salaries s ON e.emp_no = s.emp_no ORDER BY s.salary DESC LIMIT 3;
================================= Tool Message =================================
Name: sql_db_query

[('Tokuyasu', 'Pesch', 158220), ('Tokuyasu', 'Pesch', 157821), ('Honesty', 'Mukaidono', 156286)]
================================== Ai Message ==================================

The top three employees with the highest salaries are:

1. Tokuyasu Pesch with a salary of 158,220
2. Tokuyasu Pesch with a salary of 157,821
3. Honesty Mukaidono with a salary of 156,286

The LangGraph ReAct agent provides the thought-action-observation loop out of the box. However, to have more control over tool execution, you can customize a LangGraph AI agent, as shown in the following section.

Creating a Customized MySQL Agent with LangGraph

To create a customized MySQL agent, we will first define two high-level tools: get_schema_tool, which internally calls the sql_db_schema tool, and run_query_tool, which calls the sql_db_query tool from the SQLDatabaseToolkit.

from typing import Literal
from langchain_core.messages import AIMessage
from langchain_core.runnables import RunnableConfig
from langgraph.graph import END, START, MessagesState, StateGraph
from langgraph.prebuilt import ToolNode

get_schema_tool = next(tool for tool in tools if tool.name == "sql_db_schema")
get_schema_node = ToolNode([get_schema_tool], name="get_schema")

run_query_tool = next(tool for tool in tools if tool.name == "sql_db_query")
run_query_node = ToolNode([run_query_tool], name="run_query")

We want to force the agent to always call the sql_db_list_tables tool first. To achieve this, we define the list_tables method, which we will call from the first node in our graph.

def list_tables(state: MessagesState):
    tool_call = {
        "name": "sql_db_list_tables",
        "args": {},
        "id": "abc123",
        "type": "tool_call",
    }
    tool_call_message = AIMessage(content="", tool_calls=[tool_call])

    list_tables_tool = next(tool for tool in tools if tool.name == "sql_db_list_tables")
    tool_message = list_tables_tool.invoke(tool_call)
    response = AIMessage(f"Available tables: {tool_message.content}")

    return {"messages": [tool_call_message, tool_message, response]}

Next, we define the call_get_schema function, which calls the get_schema_tool that we defined earlier. This will be the second node in our graph.

def call_get_schema(state: MessagesState):

    llm_with_tools = llm.bind_tools([get_schema_tool], tool_choice="any")
    response = llm_with_tools.invoke(state["messages"])

    return {"messages": [response]}

Finally we define the prompts for nodes that generate a query and check if the query is valid.

generate_query_system_prompt = """
You are an agent designed to interact with a SQL database.
Given an input question, create a syntactically correct {dialect} query to run,
then look at the results of the query and return the answer. Unless the user
specifies a specific number of examples they wish to obtain, always limit your
query to at most {top_k} results.

You can order the results by a relevant column to return the most interesting
examples in the database. Never query for all the columns from a specific table,
only ask for the relevant columns given the question.

DO NOT make any DML statements (INSERT, UPDATE, DELETE, DROP etc.) to the database.
""".format(
    dialect=db.dialect,
    top_k=5,
)


def generate_query(state: MessagesState):
    system_message = {
        "role": "system",
        "content": generate_query_system_prompt,
    }

    llm_with_tools = llm.bind_tools([run_query_tool])
    response = llm_with_tools.invoke([system_message] + state["messages"])

    return {"messages": [response]}

check_query_system_prompt = """
You are a SQL expert with a strong attention to detail.
Double check the {dialect} query for common mistakes, including:
- Using NOT IN with NULL values
- Using UNION when UNION ALL should have been used
- Using BETWEEN for exclusive ranges
- Data type mismatch in predicates
- Properly quoting identifiers
- Using the correct number of arguments for functions
- Casting to the correct data type
- Using the proper columns for joins

If there are any of the above mistakes, rewrite the query. If there are no mistakes,
just reproduce the original query.

You will call the appropriate tool to execute the query after running this check.
""".format(dialect=db.dialect)

def check_query(state: MessagesState):
    system_message = {
        "role": "system",
        "content": check_query_system_prompt,
    }

    # Generate an artificial user message to check
    tool_call = state["messages"][-1].tool_calls[0]
    user_message = {"role": "user", "content": tool_call["args"]["query"]}
    llm_with_tools = llm.bind_tools([run_query_tool], tool_choice="any")
    response = llm_with_tools.invoke([system_message, user_message])
    response.id = state["messages"][-1].id

    return {"messages": [response]}

We also define the should_continue function, which checks if a query is accurate or not. If it is accurate, it is sent to the run_query node; otherwise, the query is generated again.

def should_continue(state: MessagesState) -> Literal[END, "check_query"]:
    messages = state["messages"]
    last_message = messages[-1]
    if not last_message.tool_calls:
        return END
    else:
        return "check_query"

The next step is to define the LangGraph with the node functions we defined. The graph executes in sequence, following the order of the nodes in the graph.

builder = StateGraph(MessagesState)
builder.add_node(list_tables)
builder.add_node(call_get_schema)
builder.add_node(get_schema_node, "get_schema")
builder.add_node(generate_query)
builder.add_node(check_query)
builder.add_node(run_query_node, "run_query")

builder.add_edge(START, "list_tables")
builder.add_edge("list_tables", "call_get_schema")
builder.add_edge("call_get_schema", "get_schema")
builder.add_edge("get_schema", "generate_query")
builder.add_conditional_edges(
    "generate_query",
    should_continue,
)
builder.add_edge("check_query", "run_query")
builder.add_edge("run_query", "generate_query")

agent = builder.compile()

display(Image(agent.get_graph().draw_mermaid_png()))

Output:

The above script shows our final AI agent graph.

Let’s ask a question and see the outputs.

question = "Give me the names of the top three employes with highest salaries"

for step in Agent.stream(
    {"messages": [{"role": "user", "content": question}]},
    stream_mode="values",
):
    step["messages"][-1].pretty_print()

Output:

The output below shows that the graph executes the nodes in the same order as they are added in the graph.

================================ Human Message =================================

Give me the names of the top three employes with highest salaries
================================== Ai Message ==================================

Available tables: departments, dept_emp, dept_manager, employees, salaries, titles
================================== Ai Message ==================================
Tool Calls:
  sql_db_schema (call_Q9g0WWat9Ti4frZXnNVYFBpq)
 Call ID: call_Q9g0WWat9Ti4frZXnNVYFBpq
  Args:
    table_names: employees, salaries
================================= Tool Message =================================
Name: sql_db_schema


CREATE TABLE employees (
	emp_no INTEGER NOT NULL,
	birth_date DATE NOT NULL,
	first_name VARCHAR(14) NOT NULL,
	last_name VARCHAR(16) NOT NULL,
	gender ENUM('M','F') NOT NULL,
	hire_date DATE NOT NULL,
	PRIMARY KEY (emp_no)
)DEFAULT CHARSET=utf8mb4 COLLATE utf8mb4_0900_ai_ci ENGINE=InnoDB

/*
3 rows from employees table:
emp_no	birth_date	first_name	last_name	gender	hire_date
10001	1953-09-02	Georgi	Facello	M	1986-06-26
10002	1964-06-02	Bezalel	Simmel	F	1985-11-21
10003	1959-12-03	Parto	Bamford	M	1986-08-28
*/


CREATE TABLE salaries (
	emp_no INTEGER NOT NULL,
	salary INTEGER NOT NULL,
	from_date DATE NOT NULL,
	to_date DATE NOT NULL,
	PRIMARY KEY (emp_no, from_date),
	CONSTRAINT salaries_ibfk_1 FOREIGN KEY(emp_no) REFERENCES employees (emp_no) ON DELETE CASCADE
)DEFAULT CHARSET=utf8mb4 COLLATE utf8mb4_0900_ai_ci ENGINE=InnoDB

/*
3 rows from salaries table:
emp_no	salary	from_date	to_date
10001	60117	1986-06-26	1987-06-26
10001	62102	1987-06-26	1988-06-25
10001	66074	1988-06-25	1989-06-25
*/
================================== Ai Message ==================================
Tool Calls:
  sql_db_query (call_OEqSCKEeVU5NRM7VXdhXkVVp)
 Call ID: call_OEqSCKEeVU5NRM7VXdhXkVVp
  Args:
    query: SELECT e.first_name, e.last_name, s.salary
FROM employees e
JOIN salaries s ON e.emp_no = s.emp_no
ORDER BY s.salary DESC
LIMIT 3;
================================== Ai Message ==================================
Tool Calls:
  sql_db_query (call_v0sSVGHXcF81WbRCFTxmGRND)
 Call ID: call_v0sSVGHXcF81WbRCFTxmGRND
  Args:
    query: SELECT e.first_name, e.last_name, s.salary
FROM employees e
JOIN salaries s ON e.emp_no = s.emp_no
ORDER BY s.salary DESC
LIMIT 3;
================================= Tool Message =================================
Name: sql_db_query

[('Tokuyasu', 'Pesch', 158220), ('Tokuyasu', 'Pesch', 157821), ('Honesty', 'Mukaidono', 156286)]
================================== Ai Message ==================================

The top three employees with the highest salaries are:

1. Tokuyasu Pesch with a salary of 158,220
2. Tokuyasu Pesch with a salary of 157,821
3. Honesty Mukaidono with a salary of 156,286

The final output displays the same response as was observed with the ReAct agent. However, in this case, you have much more control over the execution of steps in the Graph.

Developing a Simple Login Page with Python Django Framework

Fri, 09 May 2025 00:00:00 -0400

Django is a robust web framework that allows you to develop secure and scalable websites in Python. You can incorporate complex backend functionalities into your website using Python syntax.

In this beginner-level Django tutorial, you will see how to create a Django project from scratch and add a simple login page. You will see how to create URLs, views, and templates in Django.

By the end of this tutorial, you will have a working authentication flow for your web projects. Let’s get right to it!

Installing Django and Creating a Django Project

To install Django, you have to run the following pip command.

pip install django

Next, we will create a Django project named login_project using the following command. We add a dot . with the command since we want to create the project in the current working directory instead of creating a new folder.

django-admin startproject login_project .

Once you run the above command, you should see the following directories created in your current folder.

Output:

Next, we will run the Django server to see if everything is installed correctly.

python manage.py runserver

Output:

If you see the above message, your Django server started correctly.

Now open the following address in your browser http://127.0.0.1:8000/. If everything is installed correctly, you should see the following webpage.

Next, we will create the Login App within the folder. Django is a modularized framework that divides your application into different logical components. For the functionalities of our login app, we will create a separate folder called accounts. You can give it any other name if you want.

The following script creates the accounts folder.

python manage.py startapp accounts

Output:

Django will create different files for your application by default, e.g. admin, models, views, etc.

You need to register the app you create in the INSTALLED_APPS list of your parent project directory’s settings.py file. In our case, this is the settings.py file in the login_project.

Output:

Creating URLs

Our login project will have a login page for users and a dashboard page to which they will be redirected if their login is successful. We need to create URLs for these two pages.

Create a urls.py file in the accounts folder and add the following code to create URLs:

from django.urls import path
from . import views

urlpatterns = [
    path('login/', views.login_view, name='login'),
    path('dashboard/', views.dashboard_view, name='dashboard')
]

The above specifies that when the login route is hit, the login_view method in the views file should be triggered. Similarly, the dashboard route will trigger the dashboard_view method.

Creating Views

Let’s define the above login_view and dashboard_view in the accounts/views.py file.

from django.shortcuts import render, redirect
from django.contrib.auth import authenticate, login
from django.contrib import messages
from django.contrib.auth.decorators import login_required

def login_view(request):
    if request.method == 'POST':
        username = request.POST.get('username')
        password = request.POST.get('password')

        user = authenticate(request, username=username, password=password)

        if user is not None:
            login(request, user)
            return redirect('dashboard')  # ✅ redirect to dashboard now
        else:
            messages.error(request, 'Invalid username or password.')

    return render(request, 'accounts/login.html')

@login_required
def dashboard_view(request):
    return render(request, 'accounts/dashboard.html')

The above script specifies that the login_view will receive the username and password and will perform some authentication. If authentication is successful, it will redirect the request to the dashboard view. Otherwise, it will raise an error message and stay on the login.html page.

The dashboard_view returns the dashboard.html page.

The next section will create the login.html and dashboard.html pages.

Creating Templates

To create HTML pages for login and dashboard, create templates\accounts folders inside the accounts folder.

The following script shows the HTML for the login.html page.

<!DOCTYPE html>
<html>
<head>
    <title>Login</title>
</head>
<body>
    <h2>Login</h2>

    {% if messages %}
        <ul>
        {% for message in messages %}
            <li>{{ message }}</li>
        {% endfor %}
        </ul>
    {% endif %}

    <form method="post">
        {% csrf_token %}
        <label>Username:</label><br>
        <input type="text" name="username"><br><br>

        <label>Password:</label><br>
        <input type="password" name="password"><br><br>

        <button type="submit">Login</button>
    </form>
</body>
</html>

The page contains text fields for username and password and a submit button. If authentication fails, the page also displays an error message.

Here is the content for the dashboard.html page, which prints a welcome message.

<!DOCTYPE html>
<html>
<head>
    <title>Dashboard</title>
</head>
<body>
    <h2>Welcome, {{ request.user.username }}!</h2>
    <p>You are now logged in.</p>
</body>
</html>

To summarize, when you send a request, it is passed to the corresponding URL, which triggers a view and renders the corresponding HTML template.

Registering Routes

Next, you need to register the URLs from the accounts in the parent director’s urls.py file, i.e. login_project. The urls.py file should look like this.

from django.contrib import admin
from django.urls import path, include

urlpatterns = [
    path('admin/', admin.site.urls),
    path('', include('accounts.urls')),  
]

Creating Users and Testing the Application

We are now ready to create users and test our app. The first step is to create database tables that will store user information. The following script creates database tables.

python manage.py migrate

Output:

Next, run the following script to add users. By default, you must enter the username, password, and email. You can see from the output that you cannot just enter any password. Django enforces certain password requirements by default, such as minimum length and complexity, which you can see in the output.

python manage.py createsuperuser

Output:

Run the Django server again using the following command: python manage.py run server and go to http://127.0.0.1:8000/login/ in your browser. You will see the following login page. It is straightforward since we are not using any CSS styling or javascript in this code.

Output:

In case of failed authentication, you will see an error message.

Output:

If authentication is successful, you will be redirected to the dashboard.html.

Conclusion

Django is a lightweight, beginner-friendly web framework that provides out-of-the-box implementations for common web development use cases, such as login and authentication.

In this article, you created a login page using the Python Django framework. You saw how to create URLs, views, and templates in Django and how to connect them to create a minimal working authentication application.

Extracting Structured Data Using LLMs via Hugging Face API

Sat, 29 Mar 2025 00:00:00 -0400

Extracting structured information from textual data is crucial for gaining insights into what topics are discussed in the text, how sentiments are distributed, and which trends or patterns emerge over time.

This process helps transform raw, unstructured text into actionable data, helping organizations make business decisions.

With the advent of large language models (LLMs), extracting structured data from unstructured text has become more accurate and efficient than ever before.

In this article, you will see how to extract structured data from news articles using LLMs from the Hugging Face Inference API.

Importing and Installing Required Libraries

The following script imports the huggingface_hub library, which you will use to call LLMs from the Hugging Face inference API. We’re specifying a version here just so you know what we used in this tutorial, but if there’s a newer version, you’re welcome to it.

!pip install huggingface_hub==0.24.7

The script below imports the required Python libraries and modules into your Python application. Notice the HF_API_TOKEN placeholder for your Hugging Face token.

from huggingface_hub import InferenceClient
import pandas as pd
from tqdm import tqdm
import json
from google.colab import userdata
import matplotlib.pyplot as plt
tqdm.pandas()
hf_token = userdata.get('HF_API_TOKEN')

Basic Example of Extracting Structured Data

Let’s see a basic example demonstrating how to extract structured data from a simple text input.

Define the Structured Response Format

The first step is to define the format for the structured data you want to extract. You can specify the response structure in JSON format.

For example, the following JSON format will extract four properties: location of type string, activity of type string with four possible values, animals_seen of type integer with values ranging from 1 to 5, and animals of type array with a list of possible animal names.

We also specify that all four properties are required, meaning that the LLM must return values for all four properties.

response_format = {
    "type": "json",
    "value": {
        "type": "object",
        "properties": {
            "location": {"type": "string"},
            "activity": {
                "type": "string",
                "enum": ["walking", "running", "biking", "hiking"]
            },
            "animals_seen": {
                "type": "integer",
                "minimum": 1,
                "maximum": 5
            },
            "animals": {
                "type": "array",
                "items": {
                    "type": "string",
                    "enum": ["dog", "cat", "raccoon", "squirrel", "bird"]
                }
            },
        },
        "required": ["location", "activity", "animals_seen", "animals"],
    },
}

Define the Query for Structured Response

Next, we define the system role and the input query for the LLM. In the query, we tell the LLM to return values for the properties present in the JSON format we specified previously. We also provide information to the LLM on extracting values for these properties.

system_role = "You are helpful assistant in extracting structured data from text."
user_query = """
            "Please provide the following details in JSON format:\n"
            "- Location of the event\n"
            "- Type of activity (choose from: 'walking', 'running', 'biking', 'hiking')\n"
            "- Number of animals seen (between 1 and 5)\n"
            "- List of animals observed (choose from: 'dog', 'cat', 'raccoon', 'squirrel', 'bird')\n"
            "Ensure the response adheres to the specified JSON structure."
"""

Call an LLM From Hugging Face Inference API

Finally, we call a distilled DeepSeek model from the Hugging Face Inference API and pass it the system role, user query, and response format.

Again, you will need a Hugging Face Access Token to call Hugging Face Inference API.

client = InferenceClient(
    "deepseek-ai/DeepSeek-R1-Distill-Qwen-32B",
    token=hf_token,
)


output = client.chat_completion(
messages=[{"role": "system", "content": system_role},
    {"role": "user", "content": user_query}],
response_format=response_format,
max_tokens=4000,
)

output = output.choices[0].message["content"]
response = output.strip().split("</think>")[-1].strip()
print(response)

Output:

{"location": "Central Park", "activity": "walking", "animals_seen": 3, "animals": ["bird", "squirrel", "raccoon"]}

Extracting Structured Data from News Articles - A Real-world Example

In this section, we’ll show you a real-world example that extracts structured data from news articles.

Importing the Dataset

We’re going to extract structured data from the News Article dataset from Kaggle.

The following script imports the dataset and displays the dataset header.

##Dataset download link: https://www.kaggle.com/datasets/asad1m9a9h6mood/news-articles

dataset = pd.read_csv("Articles.csv", encoding="latin1")
print(f"The dataset contains {dataset.shape[0]} articles.")
dataset.head(10)

Output:

You can see that the dataset has four columns.

The NewsType column contains the article category.

dataset["NewsType"].value_counts()

Output:

Currently, we have two categories for the articles:sports and business.

Extracting Structured Data from a Single News Article

We will first extract structured information from a single news article.

We will define the extract_structured_data() function, which accepts the model client, system role, user query, and response format and returns the structured data.

For the extract_structured_data function, we will use the Qwen2.5-72B-Instruct model from the Hugging Face Inference API. You can use any other model if you want.

client = InferenceClient(
    "Qwen/Qwen2.5-72B-Instruct",
    token=hf_token,
)

def extract_structured_data (model, system_role, user_query,response_format):

  output = model.chat_completion(
  messages=[{"role": "system", "content": system_role},
      {"role": "user", "content": user_query}],
  response_format=response_format,
  max_tokens=4000,
  )

  output = output.choices[0].message["content"]
  response = output.strip().split("</think>")[-1].strip()
  return response

Next, we will define the JSON format for the structured data we want to extract.

We will extract the country, sports_category (sub-category for sports), business_category (sub-category for business), tone and conclusion using text from the article’s Article, Heading and NewsType columns.

response_format = {
    "type": "json",
    "value": {
        "type": "object",
        "properties": {
            "country": {"type": "string"},
            "sport_category": {
                "type": "string",
                "enum": [
                    "cricket", "running", "biking", "hiking", "swimming",
                    "tennis", "basketball", "football", "golf", "other"
                ]
            },
            "business_category": {
                "type": "string",
                "enum": [
                    "automotive", "consulting", "marketing", "technology", "healthcare",
                    "finance", "oil", "retail", "hospitality", "other"
                ]
            },
            "tone": {
                "type": "string",
                "enum": ["formal", "informal", "enthusiastic", "neutral", "humorous"]
            },
            "conclusion": {"type": "string"},
        },
        "required": ["country", "sport_category", "business_category", "tone", "conclusion"],
    },
}

Let’s print the article’s content from which we will extract the desired structured data.

article_title = dataset["Heading"].iloc[5]
article_text = dataset["Article"].iloc[5]
news_type = dataset["NewsType"].iloc[5]

print(f"Title: {article_title}")
print(f"News Type: {news_type}")
print(f"Text: {article_text}")

Output:

Finally, we will define the system role and the prompt and call the extract_structured_data() function.

system_role = "You are helpful assistant in extracting structured data from text."

prompt = f"""
Based on the following article details:

Title: {article_title}
News Type: {news_type}
Text: {article_text}

Please extract the following information and provide it in JSON format:
- Country which is at the centre of discussion in the article.
- Sport category (choose from: 'cricket', 'running', 'biking', 'hiking', 'swimming', 'tennis', 'basketball', 'football', 'golf', 'other').
- Business category (choose from: 'automotive', 'consulting', 'marketing', 'technology', 'healthcare', 'finance', 'oil', 'retail', 'hospitality', 'other').
- Tone of the article (choose from: 'formal', 'informal', 'enthusiastic', 'neutral', 'humorous').
- A brief conclusion summarizing the article in 50 words or less.

Ensure the response adheres to the specified JSON structure.
"""

extracted_information = extract_structured_data (client, system_role, prompt, response_format)
print(extracted_information)

Output:

The above output shows the structured data extracted from the article. The information seems correct. You can verify it by reading the article if you want.

Next, we will write a script that extracts structured data from multiple articles in the dataset.

Extracting Structured Data from Multiple News Articles

We will define the extract_structured_data_from_articles() function, which accepts a Pandas DataFrame row, extracts the article heading, text, and news type from the row embeds this information in the user query, and sends it to the extract_structured_data() function.

The JSON response from the extract_structured_data() function is converted to a Python dictionary and returned to the calling function.

def extract_structured_data_from_articles(row):

    article_title = row['Heading']
    article_text = row['Article']
    news_type = row['NewsType']

    # Define the system role and prompt
    system_role = "You are a helpful assistant in extracting structured data from text."

    system_role = "You are helpful assistant in extracting structured data from text."

    prompt = f"""
    Based on the following article details:

    Title: {article_title}
    News Type: {news_type}
    Text: {article_text}

    Please extract the following information and provide it in JSON format:
    - Country which is at the centre of discussion in the article.
    - Sport category (choose from: 'cricket', 'running', 'biking', 'hiking', 'swimming', 'tennis', 'basketball', 'football', 'golf', 'other').
    - Business category (choose from: 'automotive', 'consulting', 'marketing', 'technology', 'healthcare', 'finance', 'oil', 'retail', 'hospitality', 'other').
    - Tone of the article (choose from: 'formal', 'informal', 'enthusiastic', 'neutral', 'humorous').
    - A brief conclusion summarizing the article in 50 words or less.

    Ensure the response adheres to the specified JSON structure.
    """

    extracted_data = extract_structured_data (client, system_role, prompt, response_format)
    extracted_data_dict = json.loads(extracted_data)

    return extracted_data_dict

We randomly select 200 articles from the dataset and use the progress_apply() function to apply the extract_structured_data_from_articles() function to each row.

Finally, the list of structured data dictionaries is converted to a Pandas DataFrame and concatenated with the original dataset along the column axis.

sampled_dataset = dataset.sample(n=200, random_state=42)

structured_data = sampled_dataset.progress_apply(extract_structured_data_from_articles, axis=1)

structured_data_df = pd.DataFrame(structured_data.tolist())

final_dataset = pd.concat([sampled_dataset.reset_index(drop=True),
                           structured_data_df],
                          axis=1)
final_dataset.head()

Output:

final_dataset.to_csv("structured_news_articles.csv", index=False)

The above output shows the structured data extracted for all the rows in the sample dataset.

Visualizing Structured Data

You will want to extract insights from your structured data in most real-world scenarios. Extracting large chunks of data is kind of meaningless unless you have a way to interpret it and draw insights.

For this example, we’ll create a bar plot displaying the distribution of sports categories.

filtered_df = final_dataset[final_dataset["NewsType"] != "business"]

sport_counts = filtered_df["sport_category"].value_counts()

plt.figure(figsize=(10, 5))
sport_counts.plot(kind="bar", color="skyblue", edgecolor="black")

#Labels and title
plt.xlabel("Sport Category", fontsize=12)
plt.ylabel("Count", fontsize=12)
plt.title("Distribution of Sport Categories", fontsize=14)
plt.xticks(rotation=45)
plt.grid(axis="y", linestyle="--", alpha=0.7)

#Show plot
plt.show()

Output:

The majority of articles are about cricket, followed by football and tennis.

Similarly, you can plot business categories, as well.

filtered_df = final_dataset[final_dataset["NewsType"] != "sports"]

business_counts = filtered_df["business_category"].value_counts()

#Plot bar chart
plt.figure(figsize=(10, 5))
business_counts.plot(kind="bar", color="skyblue", edgecolor="black")

#Labels and title
plt.xlabel("Business Category", fontsize=12)
plt.ylabel("Count", fontsize=12)
plt.title("Distribution of Business Categories", fontsize=14)
plt.xticks(rotation=45)
plt.grid(axis="y", linestyle="--", alpha=0.7)

#Show plot
plt.show()

Output:

Most of the business articles discuss oil. That’s not surprising!

Finally, you can plot tone distribution.

tone_counts = final_dataset["tone"].value_counts()

#Plot bar chart
plt.figure(figsize=(10, 5))
tone_counts.plot(kind="bar", color="skyblue", edgecolor="black")

#Labels and title
plt.xlabel("Tone Category", fontsize=12)
plt.ylabel("Count", fontsize=12)
plt.title("Distribution of Tone Categories", fontsize=14)
plt.xticks(rotation=45)
plt.grid(axis="y", linestyle="--", alpha=0.7)

#Show plot
plt.show()

Output:

Since the articles are from a newspaper, they mostly have a neutral or formal tone.

Now, you know how to extract structured data from textual information, like news articles or research papers. This skill allows organizations to create interactive dashboards using structured data from your text articles important to them, which can help them make key business decisions.

Multiagent Workflow in LangGraph with DeepSeek R1 Model

Fri, 21 Feb 2025 00:00:00 -0500

In a previous tutorial, we explained how to develop a retrieval augmented generation system in the LangGraph framework. In that tutorial, we developed a single-agent workflow.

LangGraph framework allows you to develop far more complex graphs with multiagent workflows. That’s exactly what we’re going to do today.

We will use a distilled version of the DeepSeek R1 reasoning LLM from Hugging Face to develop a multiagent workflow in LangGraph. The workflow will allow us to perform RAG on a PDF document and retrieve information from a tabular dataset depending on the input query.

Let’s get started!

Installing and Importing Required Libraries

The following script installs the libraries to run scripts in this article.

!pip install langchain
!pip install langchain-core
!pip install huggingface_hub
!pip install langchain-text-splitters
!pip install langchain-community
!pip install langgraph
!pip install transformers
!pip install pypdf
!pip install chromadb
!pip install langchain-experimental
!pip install langchain_huggingface
!pip install tabulate

The script below imports the required libraries. Notice the placeholder for your Hugging Face API token. In this example, we stored this in the user data of Google Colab, but you can alter this line to hard code the token (for testing), grab it from your local environment variables or from a secure key vault, like Azure. Whatever you prefer for your normal workflow.

import os
import pandas as pd
from huggingface_hub import InferenceClient
from langchain_community.embeddings import HuggingFaceInferenceAPIEmbeddings
from langchain_community.document_loaders import PyPDFLoader
from langchain_text_splitters import RecursiveCharacterTextSplitter
from langchain_core.documents import Document
from langchain_community.vectorstores import Chroma
from langchain_core.documents import Document
from langchain_core.prompts import ChatPromptTemplate
from langchain_core.output_parsers import StrOutputParser
from langchain_huggingface import HuggingFaceEndpoint, ChatHuggingFace
from langgraph.graph import START, END, StateGraph
from langgraph.checkpoint.memory import MemorySaver
from langchain_experimental.agents import create_pandas_dataframe_agent
from langchain import hub
from typing_extensions import List, TypedDict
from pydantic import BaseModel, Field
from IPython.display import Image, display
from pydantic import BaseModel, Field
from google.colab import userdata
hf_token = userdata.get('HF_API_TOKEN')

Next, we will ingest data into a vector database for RAG operation.

Data Ingestion into Vector Database For RAG

As in the previous tutorial, we will use Alphabet’s Q3 2024 earnings call to perform RAG.

The following script imports the PDF document and splits it into chunks.

data_url = "https://abc.xyz/assets/71/a5/78197a7540c987f13d247728a371/2024q3-alphabet-earnings-release.pdf"

loader = PyPDFLoader(data_url)
docs = loader.load()

text_splitter = RecursiveCharacterTextSplitter(
    chunk_size=1000,  # chunk size (characters)
    chunk_overlap=200,  # chunk overlap (characters)
    add_start_index=True,  # track index in original document
)
all_splits = text_splitter.split_documents(docs)

print(f"Document split into {len(all_splits)} sub-documents.")

Output:

Document split into 33 sub-documents.

Next, we will use a free embedding model from HuggingFace to generate embeddings for the PDF document chunks and store them in the Chroma vector database.

embeddings = HuggingFaceInferenceAPIEmbeddings(
    api_key=hf_token,  # Replace with your Hugging Face API Key
    model_name="sentence-transformers/all-MiniLM-L6-v2"  # Specify the embedding model
)

vector_store= Chroma.from_documents(
    documents=all_splits,
    embedding=embeddings
)

Now, we are ready to create a multiagent workflow in RAG.

Creating a Multiagent Workflow in RAG

Our workflow will contain two main paths: the RAG and tabular data paths. We will create a router that accepts the user query and routes it to the concerned path.

Let’s first define the model state and the router node.

Defining State and Router Node

The model state will consist of a category attribute that stores the query category returned by the router. The question, context, and answer attributes will store the user input, the document retrieved from the vector database, and the multiagent workflow response, respectively.

class State(TypedDict):
    category:bool
    question: str
    context: List[Document]
    answer: str

In the router, we will use a distilled DeepSeek R1 LLM to assign a category to the user question. The following script creates an llm object that calls the DeepSeek model on Hugging Face.

repo_id = "deepseek-ai/DeepSeek-R1-Distill-Qwen-32B"

llm = HuggingFaceEndpoint(
    repo_id=repo_id,
    temperature=0,
    huggingfacehub_api_token=hf_token,
    max_new_tokens=4000
)

llm = ChatHuggingFace(llm=llm)

Next, we will define the router node that extracts the question from the graph’s state and uses the llm we just defined to assign one of the rag or tabular categories to the state’s category attribute.

You can see the prompt used to assign categories to user questions. You can modify the prompt and see if you get different results.

def route(state: State):

  output_parser = StrOutputParser()
  question = state["question"]

  template = f"""Here is a question from the user.
  \nQuestion: {question}
  \nYour job is to assign a category to this question
  The question can be about RAG system and earnings report for Alhabet.
  For `rag` category look for keywords like YouTube, Google, Alphabet, Revenue, etc.
  For `tabular` category look for keywords like table, data, column, row, etc.
  Assign the category 'rag' or 'tabular' based on the question.
  The response must contain a single word containing the category: which can be `rag` or `tabular`
  """

  prompt = ChatPromptTemplate.from_template(template)

  llm_chain = prompt | llm | output_parser
  output = llm_chain.invoke({"question": question})
  response = output.strip().split("</think>")[-1].strip()

  return {"category": response}

Let’s test the route node by asking it a question about Google Cloud’s revenue.

route({"question":"What is Google Cloud revenue in Q3 2023 and 2024?"})

Output:

{'category': 'rag'}

The above output shows that the route node correctly predicts the category for the question as defined in the router’s prompt.

We will also define a function that returns the category attribute’s value. We will use this function to define the conditional logic in the graph.

def select_route(state:State):
  return state["category"]

Next, we will define the nodes for RAG and tabular workflows.

Defining RAG Nodes

The following script defines the function for the retrieve node. The function uses the retriever’s similarity_search() method to retrieve the most similar documents for the RAG context.

def retrieve(state: State):
    retrieved_docs = vector_store.similarity_search(state["question"])
    return {"context": retrieved_docs}

For our RAG workflow, we will use a built-in RAG prompt from the Langchain hub. The following script shows the prompt.

prompt = hub.pull("rlm/rag-prompt")

example_messages = prompt.invoke(
    {"context": "(context goes here)", "question": "(question goes here)"}
).to_messages()

assert len(example_messages) == 1
print(example_messages[0].content)

Output:

You are an assistant for question-answering tasks. Use the following pieces of retrieved context to answer the question. If you don't know the answer, just say that you don't know. Use three sentences maximum and keep the answer concise.
Question: (question goes here)
Context: (context goes here)
Answer:

Finally, we will define the generate function, which extracts the question and context from the graph’s state and generates a response for the RAG workflow.

def generate(state: State):
    docs_content = "\n\n".join(doc.page_content for doc in state["context"])
    messages = prompt.invoke({"question": state["question"], "context": docs_content})
    output = llm.invoke(messages).content
    response = output.strip().split("</think>")[-1].strip()
    return {"answer": response}

Defining Tabular Data Node

For the tabular data workflow, we will use the sample Titanic dataset from Kaggle. You can try any other dataset in Pandas format, if you’d like. This tutorial explains how simple it is to import from Kaggle directly into Google Colab.

We will define a create_pandas_dataframe_agent() agent that we will use inside the tabular_response function to generate a response for the tabular workflow.

df = pd.read_csv('/content/Titanic-Dataset.csv')
agent = create_pandas_dataframe_agent(llm, df,
                                      verbose=True,
                                      allow_dangerous_code=True)

def tabular_response(state: State):
    response = agent.invoke(state['question'])
    return {"answer": response["output"]}

Now, we have everything we need to create our multiagent LangGraph workflow.

Putting it All Together

We can use the StateGraph class to create a graph in LangGraph.

We will add the router, retrieve, generate, and tabular nodes to our LangGraph.

The graph will start from the router node, which returns the category for the question.

Next, we add a conditional edge using the add_conditional_edges method. Here, we define the source node, which is router, and the function that we use to select the route, select_route. Based on the response from the select_route function, we either move to the retrieve or tabular nodes.

The retrieve node starts the RAG workflow, whereas the tabular node initiates the tabular.

The output of the script below shows our multiagent workflow.

graph_builder = StateGraph(State)

#Add custom-named RAG nodes
graph_builder.add_node("retrieve", retrieve)
graph_builder.add_node("generate", generate)

#Add TABULAR node (
graph_builder.add_node("tabular", tabular_response)

#Add router node with LLM-based decision-making
graph_builder.add_node("router", route)  # Custom name for the router node

#Define edges for routing logic
graph_builder.add_edge(START, "router")  # Start with the router

graph_builder.add_conditional_edges(
    "router",
     select_route,
      {"rag": "retrieve",
       "tabular": "tabular"}
)

graph_builder.add_edge("retrieve", "generate")  # Connect retrieve to generate in RAG flow
graph_builder.add_edge("generate", END)  # End after generate
graph_builder.add_edge("tabular", END)  # End after generate
#Compile the graph
graph = graph_builder.compile()

display(Image(graph.get_graph().draw_mermaid_png()))

Output:

Let’s test the graph. First, we will ask what data is stored in the table.

input = {"question":"What is stored in this table"}
result = graph.invoke(input)
print(f'Answer: {result["answer"]}')

Output:

The above output shows that the tabular workflow is triggered, which calls the pandas dataframe agent to generate a response.

Let’s ask a question about Google Cloud’s revenue.

input = {"question":"What is Google Cloud revenue in Q3 2023 and 2024?"}
result = graph.invoke(input)
print(f'Answer: {result["answer"]}')

Output:

Answer: Google Cloud's revenue for Q3 2023 was $8.411 billion and for Q3 2024 it was $11.353 billion, reflecting a 35% increase.

The router again selects the correct category and triggers the RAG workflow.

Conclusion

LangGraph multiagent workflows allow the creation of complex LLM applications involving multiple agents and paths. In this tutorial, we showed you how to create a multiagent workflow in LangGraph using the distilled DeepSeek R1 model to create RAG and tabular data retrieval workflows. We confirmed it routed properly, based on the prompt. I encourage you to try multiagent LangGraph workflows and see what LLM applications you can create!

Retrieval Augmented Generation with LangGraph Agents

Sun, 26 Jan 2025 00:00:00 -0500

In our last tutorial, we explained how to develop multi-agent chatbots with LangGraph. In this tutorial, we’ll go a step further and explain how to develop a Retrieval Augmented Generation(RAG) system with LangGraph.

Previously, most RAG and chatbot applications were developed with LangChain agents. However, owing to LangGraph’s agentic nature, companies are now adopting it as the default framework for these applications.

LangGraph is a framework built on top of LangChain. It does not entirely replace LangChain; rather, it uses various components from LangChain.

Installing and Importing Required Libraries

The following script installs the libraries to run scripts in this tutorial.

!pip install langchain-community
!pip install langchain-openai
!langchain-text-splitters
!pip install langgraph
!langchain-core
!pip install pypdf
!pip install chromadb

The script below imports the required libraries into your Python application. Notice the placeholder for your API key.

from langchain_openai import ChatOpenAI
from langchain_openai import OpenAIEmbeddings
from langchain_community.document_loaders import PyPDFLoader
from langchain_text_splitters import RecursiveCharacterTextSplitter
from langchain_core.documents import Document
from langchain_community.vectorstores import Chroma
from langchain_core.documents import Document
from langgraph.graph import START, StateGraph
from langgraph.checkpoint.memory import MemorySaver

from typing_extensions import List, TypedDict
from IPython.display import Image, display
import os

from google.colab import userdata
os.environ["OPENAI_API_KEY"] = userdata.get('OPENAI_API_KEY')

Data Ingestion into Vector Database

The first step in a RAG application is to import data, create vector embedding from the data, and ingest the embeddings into a vector database.

The following script loads text from a PDF document. The PDF document contains Alphabet’s earnings call for Q3 2024.

data_url = "https://abc.xyz/assets/71/a5/78197a7540c987f13d247728a371/2024q3-alphabet-earnings-release.pdf"

loader = PyPDFLoader(data_url)
docs = loader.load()

Next, we will split our PDF document into smaller chunks of 1000 characters, with an overlap of 200 characters between each chunk. This approach helps RAG models retrieve more relevant information that closely aligns with the user’s query. The overlap is crucial because it maintains the flow of information across chunk boundaries, preventing the loss of context which might occur if the text were split without any overlap.

text_splitter = RecursiveCharacterTextSplitter(
    chunk_size=1000,  # chunk size (characters)
    chunk_overlap=200,  # chunk overlap (characters)
    add_start_index=True,  # track index in original document
)
all_splits = text_splitter.split_documents(docs)

print(f"Document split into {len(all_splits)} sub-documents.")

Output:

Document split into 33 sub-documents.

Finally, we create vector embeddings from the text chunks and insert them into the Chroma vector database. You can use any other database if you want. We’ll use OpenAI embeddings to create text chunks.

embeddings = OpenAIEmbeddings()

vector_store= Chroma.from_documents(
    documents=all_splits,
    embedding=embeddings
)

That’s all we have to do for our data ingestion. The next step is to retrieve it.

Data Retrieval

To retrieve the data we just ingested, we need a prompt that embeds the context (the data ingested and retrieved from the vector database) into the query we will send to our LLM. To do so, you can write your own prompt or use a RAG prompt from a long-chain hub, as the following script shows.

from langchain import hub

prompt = hub.pull("rlm/rag-prompt")

example_messages = prompt.invoke(
    {"context": "(context goes here)", "question": "(question goes here)"}
).to_messages()

assert len(example_messages) == 1
print(example_messages[0].content)

Output:

The above output shows the prompt we will use to invoke an LLM.

Next, we will define the state of our LangGraph. A LangGraph agent’s state contains information shared between nodes and edges of a graph. In our case, the agent state will consist of a question containing the user query, the context containing the documents retrieved from the vector database, and the answer containing the LLM response.

We will also define the retrieve() function that will serve as a node in our LangGraph. The retrieve() function will return the documents from the vector database that matches the user query. These documents will be stored in the context of the agent state.

We will ask a question to test the retrieve() function and see what documents are returned.

class State(TypedDict):
    question: str
    context: List[Document]
    answer: str

def retrieve(state: State):
    retrieved_docs = vector_store.similarity_search(state["question"])
    return {"context": retrieved_docs}

context = retrieve({"question":"How much did Alphabet make from YouTube Ads Revenue?"})
context

Output:

Most of the documents are relevant to the user query.

Response Generation

In the generation step, the user question and the retrieved context documents are passed to the LLM to generate a response.

To do so, we will define the generate() function, which extracts the context from the documents, embeds the context and the user query in the prompt, and sends the prompt to the OpenAI GPT-4o LLM. Finally, the function stores the response in the state’s response attribute.

llm = ChatOpenAI(model = 'gpt-4')

def generate(state: State):
    docs_content = "\n\n".join(doc.page_content for doc in state["context"])
    messages = prompt.invoke({"question": state["question"], "context": docs_content})
    response = llm.invoke(messages)
    return {"answer": response.content}

Putting It All Together: Creating a RAG LangGraph Agent

To create a LangGraph agent, we will use the StateGraph object and pass it the state object we defined earlier. Next, we will add the retrieve and generate nodes to our graph and set the retrieve node as the start point.

Finally, we will compile the graph and display its structure.

graph_builder = StateGraph(State).add_sequence([retrieve, generate])
graph_builder.add_edge(START, "retrieve")
graph = graph_builder.compile()

display(Image(graph.get_graph().draw_mermaid_png()))

Output:

The above output shows that we have two nodes in the graph: retrieve and generate, corresponding to the two functions we defined earlier. The input to the graph will be the user query in the question attribute of the state object. The retrieve node will retrieve the context related to the user query and store it in the context attribute.

Next, the generate node will extract the context and the question attributes from the state object and embed them into the prompt sent to the LLM. The LLM’s response is stored in the answer attribute.

You can now invoke the LangGraph graph using the invoke() method. Let’s test the graph by asking a simple question. The following script asks LangGraph about Google Cloud’s revenue for Q3 of 2023 and 2024.

input = {"question":"What is Google Cloud revenue in Q3 2023 and 2024?"}
result = graph.invoke(input)
print(f'Answer: {result["answer"]}')

Output:

Answer: The Google Cloud revenue in Q3 2023 was $8.411 billion. In Q3 2024, the Google Cloud revenue increased to $11.353 billion.

The above output is correct; you can verify it from the document.

You can also stream LangGraph model responses using the stream() function, as the following script shows.

input = {"question":"How much did Alphabet make from YouTube Ads Revenue in Q3 2023 and 2024?"}

for message, metadata in graph.stream(input, stream_mode="messages"):
    print(message.content, end="")

Output:

Alphabet made $7.952 billion from YouTube ads revenue in Q3 2023 and $8.921 billion in Q3 2024.

Going Further: Adding Memory to Conversations

Right now, we’ve just created an agent that allows you to ask one question and get one answer, but it is possible to have a stateful conversation with LangGraph agents, where LangGraph remembers the conversation history and responds accordingly.

To do so, create an object of the MemorySaver class and pass it to the checkpointer argument of a graph’s compile() method.

Next, when invoking a graph, you need to pass the configurable dictionary with the conversation’s thread_id.

Let’s ask a question followed by a second question referring to the information in the previous question.

memory = MemorySaver()
graph = graph_builder.compile(checkpointer=memory)
config = {"configurable": {"thread_id": "1"}}


input = {"question":"What was Google Cloud's revenue in Q3 2023 and 2024?"}
result = graph.invoke(input,
                      config=config,)
print(f'Answer: {result["answer"]}')

Output:

Answer: The Google Cloud revenue in Q3 2023 was $8.411 billion. In Q3 2024, the revenue increased to $11.353 billion.

The above out shows the correct answer. Next, we will ask a question that refers to the information in the above question.

input = {"question":"And for YouTube ads?"}
result = graph.invoke(input,
                      config=config,)
print(f'Answer: {result["answer"]}')

Output:

Answer: The revenue from YouTube ads increased from $7,952 million in the third quarter of 2023 to $8,921 million in the third quarter of 2024. Furthermore, YouTube's total ads and subscription revenues surpassed $50 billion over the past four quarters for the first time. This indicates a positive growth trend in YouTube's ad revenue.

You can see that LangGraph remembers details from the previous question and used that context to answer the question about YouTube ads. Behavior like this is great for creating your own application, like a chatbot.

Conclusion

In this tutorial, you saw how to develop a RAG system in LangGraph and extract information from a custom PDF document. LangGraph is an excellent framework for developing agentic LLM applications. It certainly comes highly recommended if you’re developing complex and multi-agent applications using LLMs.

How to Develop Multi-agent Chatbots with LangGraph Agents

Sun, 24 Nov 2024 00:00:00 -0500

LangGraph is an agentic AI workflow built on LangChain. LangGraph allows you to create chatbots that dynamically route queries to specialized agents for tasks like searching the web, fetching data from Wikidata, or handling general questions.

This approach provides a more flexible, modular chatbot design that can tap into different data sources based on the nature of the user’s question.

In this tutorial, you will learn how to set up LangGraph and create a multi-agent chatbot using ReAct agents. We will walk through the entire process, from installing the necessary libraries to configuring agents that can interact with external tools.

By the end of this tutorial, you’ll have a functional multi-agent chatbot that can intelligently classify and respond to different types of user requests.

Installing and Importing Required Libraries

The following script installs the Python libraries to run scripts in this article.

!pip install langchain-core
!pip install -U langgraph
!pip install langchain-community
!pip install -qU langchain-openai
!pip install google-search-results
!pip install --upgrade --quiet "wikibase-rest-api-client<0.2" mediawikiapi

The script below imports the required libraries into your Python application. Notice the placeholders for API keys, which you’ll need to fill in with your own keys.

from langchain_core.tools import tool
from langchain_community.tools.wikidata.tool import WikidataAPIWrapper, WikidataQueryRun
from langchain_community.utilities import SerpAPIWrapper
from pydantic import BaseModel, Field
from typing import Optional, TypedDict, Annotated
from langchain_core.messages import AnyMessage, SystemMessage, HumanMessage
from langchain_openai import ChatOpenAI
from langgraph.graph import StateGraph, END
from IPython.display import Image, display
from langgraph.prebuilt import create_react_agent
import sqlite3
import math
import re
from google.colab import userdata
serp_api_key = userdata.get('SERP_API_KEY')
openai_api_key = userdata.get('OPENAI_API_KEY')

Defining Tools

You can create LangGraph agents without tools, as well. However, tools are what makes agents powerful. Tools allow LLM agents to access external information and provide responses based on that information.

For example, using an LLM, you can use tools to access YouTube, the Internet, and Wikipedia. By default, LLMs do not have access to these sources of information.

To define a tool, you must define a method it will call. In the following script, we define the get_wikidata_data() method, which uses LangChain’s Wikidata wrapper to search the Wikidata database against the search query.

def get_wikidata_data(search_query):
    wikidata = WikidataQueryRun(api_wrapper=WikidataAPIWrapper())
    wikidata_response = wikidata.run(search_query)
    return wikidata_response

print(get_wikidata_data("Eifel Tower"))

Output:

Once you define a tool method, you can create a tool by defining a method with the @tool annotator.

The following script defines the search_wikidata tool that accepts WikidataTopic type data, which is a simple topic string in the script below. The tool then passes the topic string to the get_wikidata_data() method to retrieve a final response.

A tool’s description is fundamental. Agents look at tool descriptions to decide which tool to call. In the script below, we define that the tool Returns information from Wikidata about the searched topic.

class WikidataTopic(BaseModel):
  topic: str = Field(description="The topic to be searched on Wikidata")

@tool(args_schema = WikidataTopic)
def search_wikidata(topic: str) -> str:
  """Returns information from Wikidata about the searched topic"  ""
  return get_wikidata_data(topic)

Similarly, let’s define another tool that uses LangChain’s Serp API wrapper to fetch search engine results for a given query.

The following script defines the get_websearch_results() method we will use in our tool.

def get_websearch_results(query):
  search = SerpAPIWrapper(serpapi_api_key = serp_api_key)
  return search.run(query)

get_websearch_results("Who is winning the US presidential election in 2024?")

Output:

The script below defines the search_web tool, which, given a query, calls the get_websearch_results() method to search the Internet.

class WebSearchTopic(BaseModel):
  topic: str = Field(description="The topic to be searched on the internet")

@tool(args_schema = WebSearchTopic)
def search_web(topic: str) -> str:
  """Returns information from the internet about the searched topic"  ""
  return get_websearch_results(topic)

We have defined our tools. Next, we will create our LangGraph multi-agent system.

Creating a Multi-agent LangGraph

We will first create a router node in our graph that, given a user query, directs the query to the most suitable node of our graph.

Next, we will define graph nodes and the tools that these nodes can access. Finally, we will add the graph nodes to our multi-agent graph.

Creating a Router for Query Classification

LangGraph agents use LLM. The following script defines the get_llm() method that returns the OpenAI GPT-4o LLM.

The script also defines the MultiAgentState typed dictionary, which stores the state of our graph. A graph’s state contains information shared between all nodes in a graph. In our state, we will add the user query, the query_type that decides which node to select based on the user query, and the model response.

def get_llm():

  llm = ChatOpenAI(api_key = openai_api_key,
                 temperature = 0,
                model_name = "gpt-4o")
  return llm

class MultiAgentState(TypedDict):
    query: str
    query_type: str
    response: str

Next, we will define the router and the router node prompt. The prompt tells the LLM to select one of the three categories: WIKIDATA, WEB, or GENERAL based on the user input.

We define the router_node() that accepts the graph’s state and passes the router prompt and the user query from the state to our LLM model. The model response is stored in the query_type attribute of the graph state.

query_category_prompt = """
You are an expert in assigning correct categories to user queries.
Depending on your answer, the question will be routed to one of the agents.
There are 3 possible question types:
- WIKIDATA- questions related to an entity, place, object or a famous person or question about facts
- WEB - questions asking to search something on the internet
- GENERAL - general questions
Return in the output only one word (WIKIDATA, WEB or GENERAL).
"""

def router_node(state: MultiAgentState):
  messages = [
    SystemMessage(content = query_category_prompt ),
    HumanMessage(content=state['query'])
  ]
  llm = get_llm()
  response = llm.invoke(messages)
  return {"query_type": response.content}

Let’s test our router first. We will create a LangGraph graph using the StateGraph class and pass the graph’s state to the StateGraph constructor.

Next, we add the router_node to our graph using the add_node method. Note that we can assign a node ID (router in this case) to our node.

We set the router node as the entry point of our graph and add the edge from the router node to the END. In this case, the graph simply takes user input and returns the corresponding node category, e.g., WIKIDATA, WEB, or GENERAL.

Finally, we compile our graph and display it.

builder = StateGraph(MultiAgentState)
builder.add_node("router", router_node)

builder.set_entry_point("router")
builder.add_edge('router', END)

graph = builder.compile()

display(Image(graph.get_graph().draw_mermaid_png()))

Output:

Let’s test our graph. We will pass a dictionary containing the query key and the corresponding user input.

graph_input = {'query': "Give me some latest news about microsoft"}
output = graph.invoke(graph_input)
print(output)

Output:

{'query': 'Give me some latest news about microsoft', 'query_type': 'WEB'}

In the above output, you can see the graph state at this point. The model thinks that given the input query, the query_type should be WEB.

Let ask a different question.

graph_input= {'query': "Take two to the power of 5"}
output = graph.invoke(graph_input)
print(output)

Output:

{'query': 'Take two to the power of 5', 'query_type': 'GENERAL'}

In this case the query_type is GENERAL.

Next, we will define the nodes that will be selected based on the query type.

Creating Nodes to add in LangGraph

First, we will define the wikidata_search_node node. This node is called when the query type is WIKIDATA.

The node uses a built-in LangGraph’s ReAct agent to call the search_wikidata tool we created earlier and return a response from Wikidata.

wikidata_search_prompt ='''
You have access to Wikidata.
Your job is to search Wikidata for the latest relevant information based on a given query and return only the information retrieved from Wikidata.
You don't add anything yourself and only provide the exact information found.
'''

def wikidata_search_node(state: MultiAgentState):
    llm = get_llm()
    wikidata_agent = create_react_agent(llm,
                                        [search_wikidata],
                                         state_modifier = wikidata_search_prompt)

    messages = [HumanMessage(content=state['query'])]
    result = wikidata_agent.invoke({"messages": messages})
    print(result)
    return {'response': result['messages'][-1].content}

Similarly, the following script defines the web_search_node, which is called when the query type is WEB. This node uses the ReAct agent to call the search_web tool.

web_search_prompt = '''
You can search the internet, particularly Google.
Your job is to search the internet for the latest relevant information based on a given query and return only the information retrieved from the internet.
You don't add anything yourself and only provide information from other sources.
'''

def web_search_node(state: MultiAgentState):
    llm = get_llm()
    web_agent = create_react_agent(llm,
                                        [search_web],
                                         state_modifier = web_search_prompt)

    messages = [HumanMessage(content=state['query'])]
    result = web_agent.invoke({"messages": messages})
    return {'response': result['messages'][-1].content}

Finally, we define the general_assistant_node which simply uses an LLM to return the model response.

general_prompt = '''
You're a friendly assistant and your goal is to answer general questions.
Please don't provide any unchecked information; just say that you don't know if you don't have enough information.
'''

def general_assistant_node(state: MultiAgentState):
    messages = [
        SystemMessage(content=general_prompt),
        HumanMessage(content=state['query'])
    ]
    llm = get_llm()
    response = llm.invoke(messages)
    return {"response": response.content}

We will also define the route_query method, which returns the value of the graph’s state’s query_type attribute at any given moment.

def route_query(state: MultiAgentState):
    return state['query_type']

Adding Nodes and Compiling the Graph

Let’s define our multi-agent graph now. We will add the router_node,, the wikidata_search_node, web_search_node, and the general_assistant_node to our graph. We name the last three nodes wikidata_search, web_search, and general_assistant, respectively.

We will also add a conditional edge that starts from the router_node, calls the route_query, and goes to one of the last three nodes, based on its output.

We set the router_node as the entry node and add edges from the wikidata_search, web_search, and general_assistant nodes to the END node.

Finally, we compile the model and display its graph.

builder = StateGraph(MultiAgentState)
builder.add_node("router", router_node)
builder.add_node('wikidata_search', wikidata_search_node)
builder.add_node('web_search',  web_search_node)
builder.add_node('general_assistant', general_assistant_node)
builder.add_conditional_edges(
    "router",
    route_query,
    {'WIKIDATA': 'wikidata_search',
     'GENERAL': 'general_assistant',
     'WEB': 'web_search'}
)


builder.set_entry_point("router")
builder.add_edge('wikidata_search', END)
builder.add_edge('web_search', END)
builder.add_edge('general_assistant', END)
graph = builder.compile()

display(Image(graph.get_graph().draw_mermaid_png()))

Output:

Let’s test our multi-agent LangGraph. The following script asks for facts about Empire state building. We stream the graph response.

graph_input = {'query': "Give me some facts about Empire state building"}
results = []
for s in graph.stream(graph_input):
  print(s)
  results.append(s)

Output:

The above output shows that the graph assigns the WIKIDATA query type to the user query and then calls the wikidata_search node to retrieve a model response.

Let’s ask another question. This time, we asked the graph to answer a query related to the current situation.

The output shows that the graph assigned the WEB type to the user query and moved to the web_search node to retrieve the final response.

graph_input = {'query': "Who is winning the US Presidential elections right now?"}
results = []
for s in graph.stream(graph_input):
  print(s)
  results.append(s)

Output:

If you are only interested in the graph’s final response, you can retrieve the response key from the graph’s output.

output =  graph.invoke(graph_input)
print(output['response'])

Output:

Finally, let’s create the chatbot() function that executes a while loop to receive user input. The method then calls the graph we created to return the model response. The while loop continues unless the user enters quit, in which case the loop terminates.

def chatbot(graph):
    results = []

    while True:

        query = input("\033[1m User >>:\033[0m")

        if query.lower() == "quit":
            print("Chatbot: Goodbye!")
            break

        input_data = {'query': query}

        # Retrieve and process response from graph
        output = graph.invoke(input_data)  # Use input_data instead of input
        print("Chatbot:", output['response'])
        results.append(output['response'])

chatbot(graph)

Output:

The above output shows our chatbot in action.

Conclusion

In this tutorial, you saw how to implement a multi-agent LangGraph agent in Python.

LangGraph is a state-of-the-art agentic AI workflow built on top of LangChain. Compared to default LangChain agents, LangGraph offers high flexibility and can implement complex agentic workflows more efficiently. I encourage you to use LangGraph to implement all your future LLM applications.

YouTube Chatbot in LangChain Using Alibaba Qwen 2.5 Model

Sun, 20 Oct 2024 00:00:00 -0400

On September 19, 2024, Alibaba released Qwen 2.5 series of models that outperformed state-of-the-art open-source large language models (LLMs) on several benchmarks.

In this article, you will see how to develop a retrieval augmented generation (RAG) chatbot in LangChain. The chatbot will be capable of answering questions related to YouTube videos.

We will import the Qwen 2.5-7b model from Hugging Face to develop our chatbot. You can also use the Qwen 2.5-72b model if you have more powerful GPUs. The process remains exactly the same.

So, let’s begin without ado.

Note: The scripts in this article are run using Google Colab.

Installing and Importing Required Libraries

You must install the following libraries to run scripts in this article.

!pip install -q -U transformers
!pip install -q -U sentence-transformers
!pip install -q -U faiss-cpu
!pip install -q -U langchain
!pip install langchain-community
!pip install -U langchain-huggingface
!pip install -q -U youtube-transcript-api
!pip install -q -U pytube

The following script imports the required libraries.

from transformers import AutoModelForCausalLM, AutoTokenizer, logging, pipeline
from langchain_huggingface import HuggingFacePipeline
from langchain.embeddings import HuggingFaceEmbeddings
from langchain_core.prompts import PromptTemplate
from langchain_core.prompts import ChatPromptTemplate
from langchain_core.output_parsers import StrOutputParser
from langchain_community.document_loaders import YoutubeLoader
from langchain.text_splitter import RecursiveCharacterTextSplitter
from langchain.vectorstores import FAISS
from langchain.chains import create_retrieval_chain
from langchain.chains.combine_documents import create_stuff_documents_chain
from langchain_community.chat_message_histories import ChatMessageHistory
from langchain_core.runnables.history import RunnableWithMessageHistory
from langchain_core.prompts import MessagesPlaceholder
from langchain.chains import create_history_aware_retriever
import warnings

logging.set_verbosity(logging.CRITICAL)

Importing Qwen 2.5 LLM from Hugging Face in LangChain

Before we develop a YouTube question-answering chatbot, let’s first see how to generate text using the Qwen 2.5-7b model in LangChain.

We will first import the Qwen 2.5-7B instruct model and the corresponding tokenizer from Hugging Face.

model_name = "Qwen/Qwen2.5-7B-Instruct"
model = AutoModelForCausalLM.from_pretrained(
    model_name,
    torch_dtype="auto",
    device_map="auto"
)
tokenizer = AutoTokenizer.from_pretrained(model_name)

Next, we will create a LangChain Hugging Face pipeline for the Qwen 2.5-7b model you just imported.

We will convert the pipeline to a LangChain LLM by passing the pipeline object to the HuggingFacePipeline class.

hf_pipe = pipeline("text-generation",
                model=model,
                tokenizer=tokenizer,
                max_new_tokens=1048)

llm = HuggingFacePipeline(pipeline=hf_pipe)

Now, you can use the Qwen 2.5-7B model like any other LLM in LangChain. Let’s see an example. In the script below, we create a LangChain chain using the Qwen 2.5-7B model to answer Python-related questions.

We ask the LLM to generate a function that takes a cube of a number, squares it, and finally adds 2 to it.

template = """You are an expert Python Developer. Give me a function that does the following:
{function_description}"""

prompt = PromptTemplate.from_template(template)

chain = prompt | llm | StrOutputParser()

description = "takes cube of a number then squares it and adds 2 to the result"
print(chain.invoke({"function_description": description}))

Output:

The above output shows that the Qwen 2.5-7b model gave us a function along with its explanation.

Let’s test the above function.

def transform_number(x):
    # Step 1: Cube the number
    cubed = x ** 3

    # Step 2: Square the cubed result
    squared_cubed = cubed ** 2

    # Step 3: Add 2 to the squared cubed result
    result = squared_cubed + 2

    return result

#Example usage:
print(transform_number(2))  # Output: 66

Output:

The output shows that the function works perfectly.

Let’s now see how to develop a RAG chatbot with the Qwen 2.5-7b model in LangChain.

Retrieval Augmented Generation with Qwen 2.5 in LangChain

In this section, you will see how to develop a Chatbot that will give you answers to your questions about a YouTube video.

Generating Embeddings from YouTube Videos

We will import the text of Meta’s earnings call for the second quarter of 2024. As the following script shows, you can use LangChain’s YoutubeLoader to load the content of a YouTube video.

url = "https://www.youtube.com/watch?v=uY3E-7jU8Xo"
doc = YoutubeLoader.from_youtube_url(url).load()
doc[0].page_content

Output:

Next, we will split the content of the YouTube video into smaller chunks since Vector databases show better performance for semantic similarity of smaller text chunks.

text_splitter = RecursiveCharacterTextSplitter(
    chunk_size=1000,
    chunk_overlap=200,
    length_function=len,
)

text_splitter = RecursiveCharacterTextSplitter()
documents = text_splitter.split_documents(doc)
print(f"Number of documents: {len(documents)}")
print(f"Last Document: {documents[-1].page_content}")

Output:

Finally, we will convert the text chunks into vector embeddings and store them in a vector retriever store.

model_path = "thenlper/gte-large"
embeddings = HuggingFaceEmbeddings(
    model_name = model_path
)

embedding_vectors = FAISS.from_documents(documents, embeddings)
retriever = embedding_vectors.as_retriever()

Creating Chatbot Response Based on Documents

Now, we are ready to create our chatbot. To do so, we need to create two chains: a stuff document chain and a retriever chain.

The stuff document chain will create a placeholder (context) for storing the contents of the YouTube video retrieved by the retriever chain. The retriever chain will use the vector retriever to retrieve the YouTube content that best answers the user’s question using the vector similarity search.

#source: https://python.langchain.com/docs/tutorials/rag/

system_prompt = (
    "You are an assistant for question-answering tasks. "
    "Use the following pieces of retrieved context to answer "
    "the question. If you don't know the answer, say that you "
    "don't know. You dont add any additional information in the response and just provide concise answer."
    "Answer in three sentences at the maximum"
    "\n\n"
    "{context}"
)

prompt = ChatPromptTemplate.from_messages(
    [
        ("system", system_prompt),
        ("human", "{input}"),
    ]
)

question_answer_chain = create_stuff_documents_chain(llm, prompt)
rag_chain = create_retrieval_chain(retriever, question_answer_chain)

Once we create the retrieval chain, we can ask questions about the YouTube video, as shown in the following script.

input = "What are Meta revenue goals and expected outlook for Q3?"
response = rag_chain.invoke({"input": input })
response["answer"].split(input)[1]

Output:

The above output shows that the Qwen 2.5-7B model correctly answers our query. You can verify this by searching the video’s contents directly.

Let’s ask another question.

input = "What are the major risks for Q3?"
response = rag_chain.invoke({"input": input })
response["answer"].split(input)[1]

Output:

Again, the model returns the correct output.

Conclusion

The Qwen 2.5 series of models have proven to be state-of-the-art open-source LLMs. In this article, you saw how to create a RAG chatbot using Qwen 2.5-7B and hopefully you saw that it performed pretty well! I encourage you to develop your RAG chatbot using Qwen 2.5 and LangChain and share your feedback.

Time Series Prediction with Hugging Face Transformers

Thu, 19 Sep 2024 00:00:00 -0400

Time series data refers to data dependent on time, such as stock market prices, inflation rates, and daily weather. In some cases, predicting future time series values is crucial. The act of making these predictions is known as time series forecasting or time series prediction.

This tutorial will show you how to classify future time series data using a transformer model from the Python Hugging Face library. Transformer models were initially designed for text-processing tasks such as generation and classification. However, due to the similarity between textual data and time series data in their sequential nature, transformer models have also been adapted for time series data classification.

In this tutorial, we will use the Amazon Chronos transformer from the Hugging Face library to predict future stock prices.

Installing and Importing Required Libraries

The following script downloads the Chronos models.

!pip install git+https://github.com/amazon-science/chronos-forecasting.git

If you’re following this tutorial in Google Colab, you won’t have to install any other libraries.

The script below imports the required libraries into your Python application.

import matplotlib.pyplot as plt
import numpy as np
import pandas as pd
import torch
from sklearn.metrics import mean_absolute_error, mean_squared_error
from chronos import ChronosPipeline

Importing and Preprocessing Stock Market Data

We will use Apple stock price data for the last year (from August 2023 to August 2024) to predict stock prices. We will predict the opening stock price for the last 22 days. This will be our test set. The stock prices for the previous days will be used as the context.

You can download the data from Yahoo Finance in CSV format, or you can copy and paste the history table into an Excel sheet and save it as a CSV - just remember to delete any dividend rows. The script below imports the CSV file into a Pandas DataFrame and displays the data shape and header.

##dataset link
##https://finance.yahoo.com/quote/AAPL/history/

apple_dataset = pd.read_csv("AAPL.csv")
print(apple_dataset.shape)
apple_dataset.head()

Output:

The dataset consists of 252 records. We will predict the opening stock prices using the Chronos model.

As discussed, we will use the last 22 days of data for testing and the remaining data as the context for the time series model. Based on the context, the model will predict the opening stock prices for the last 22 days.

The following script divides the data into test and context sets:

#Calculate the index to split the data
test_size = 22
split_index = len(apple_dataset) - test_size

#If the dataframe is shorter than 22 rows, all goes to test
if split_index < 0:
    train_open = pd.Series(dtype=float)
    test_open = apple_dataset['Open']
else:
    # Splitting the Open column into training and test sets
    train_open = apple_dataset['Open'].iloc[:split_index]
    test_open = apple_dataset['Open'].iloc[split_index:]

Importing Chronos Time Series Model Making Predictions using

We will create a Hugging Face pipeline that uses the amazon chronos-t5-tiny model for time series prediction. You can also use the mini, small, base, or large models.

pipeline = ChronosPipeline.from_pretrained(
  "amazon/chronos-t5-tiny",
  device_map="cuda",
  torch_dtype=torch.bfloat16,
)

Next, we’ll convert the context or training data to PyTorch tensors since the Chronos models use PyTorch on the backend.

Finally, you need to pass the context and the prediction length (22 in this case) to the pipeline’s predict() method to make predictions.

context = torch.tensor(train_open)
prediction_length = test_size
forecast = pipeline.predict(context, prediction_length)

The Chronos models make 20 predictions for each time step. We will divide the data into ten quartiles and take the prediction for the 1st, 5th, and 9th quartiles. The 5th quartile represents median values. The data between the 1st and 9th quartiles will represent the 80% prediction interval.

Next, we can plot the context and the median predictions in a single figure, as shown in the following script:

forecast_index = range(len(train_open), len(train_open) + prediction_length)
low, median, high = np.quantile(forecast[0].numpy(), [0.1, 0.5, 0.9], axis=0)

plt.figure(figsize=(8, 4))
plt.plot(train_open, color="royalblue", label="historical data")
plt.plot(forecast_index, median, color="tomato", label="median forecast")
plt.fill_between(forecast_index, low, high, color="tomato", alpha=0.3, label="80% prediction interval")
plt.legend()
plt.grid()
plt.show()

Output:

Finally, we will plot the predicted and actual stock prices in the test set in a single plot.

forecast = np.squeeze(forecast)  
low, median, high = np.quantile(forecast, [0.1, 0.5, 0.9], axis=0)
forecast_index = range(len(test_open))

plt.figure(figsize=(8, 5))
plt.plot(forecast_index, test_open, color="royalblue", label="actual price")
plt.plot(forecast_index, median, color="tomato", label="median forecast")
plt.fill_between(forecast_index, low, high, color="tomato", alpha=0.3, label="80% prediction interval")
plt.legend()
plt.grid()
plt.show()

Output:

You can see that most of the predictions are within an 80% prediction interval, with the later predictions being highly accurate.

Let’s calculate the mean absolute error values to see how much the model err on average.

mae = mean_absolute_error(test_open, median)
print("Average open values in the training set:", train_open.mean())
print("Mean Absolute Error (MAE):", mae)

Output:

Average open values in the training set: 186.99199952608697
Mean Absolute Error (MAE): 4.38785126586283

The above output shows that, on average, our model predictions are more than 4 points off, which is 2.1% of the average stock prices in the training set. This is impressive, given that the model is not trained on any data but uses context and the pre-trained weights to predict future time series values.

Conclusion

Transformer models have demonstrated state-of-the-art performance for text classification. They have also been developed for time series data prediction.

In this tutorial, you saw how to make time-series predictions for stock market data using Amazon Chronos models from Hugging Face. Though it’d be naive to think this result could be replicated to reliably predict actual stock prices, it’s still a neat demonstration. I encourage you to try this model for other time series tasks. Happy Coding!

P.S. I ran this same experiment with 1-year of VTIAX, and the actual price was consistently outside the 80% prediction interval, so don’t get too excited!

Anthropic Claude 3.5 Sonnet - Is it better than ChatGPT?

Fri, 23 Aug 2024 00:00:00 -0400

Anthropic released Claude 3.5 Sonnet LLM on June 20, 2024. According to Anthropic, Claude 3.5 Sonnet outperforms OpenAI GPT-4o (the model that powers ChatGPT) on several benchmarks. At the time of this article, livebench.ai, a reliable LLM leaderboard, also places Claude 3.5 Sonnet at the first rank for the Global LLM benchmark average.

Inspired by these numbers, we tried to perform a few experiments, namely zero-shot text classification and zero-shot text summarization, to compare the performance of Claude 3.5 Sonnet and OpenAI GPT-4o. We’ll share our findings in this article and also show you how to use these LLMs with Python.

By the end of this article, you will know how to call the Anthropic and OpenAI APIs to perform zero-shot text classification and summarization. You will also see which model is better for these tasks.

Let’s get to it!

Importing and Installing Required Libraries

You will need to install the Anthropic and OpenAI Python libraries. In addition, we will install the rouge-score module to evaluate the text summarization performance of different LLMs.

!pip install anthropic
!pip install openai
!pip install rouge-score

The following script imports the required libraries into your Python application.

import os
import pandas as pd
from sklearn.model_selection import train_test_split
from sklearn.metrics import accuracy_score
import anthropic
from openai import OpenAI
from rouge_score import rouge_scorer

Claude 3.5 Sonnet vs GPT-4o For Text Classification

Let’s first compare Claude 3.5 Sonnet and GPT-4o for text classification.

Importing and Preprocessing the Dataset

We will use the US Consumer Finance Complaints dataset to perform zero-shot classification. The dataset consists of customer complaints about different financial products. The script below imports the dataset CSV file into a Pandas dataframe.

##Dataset Link
##https://www.kaggle.com/datasets/kaggle/us-consumer-finance-complaints

dataset = pd.read_csv(r"D:\Datasets\consumer_complaints.csv")
print(dataset.shape)
dataset.head()

Output:

The dataset consists of more than 550k records. The consumer_complaint_narrative column contains complaint text, while the product column contains the corresponding text. We will use LLMs to predict the value for the product column using the consumer_complaint_narrative text as input.

Let’s print the number of complaints for each product category:

dataset["product"].value_counts()

Output:

The dataset is highly imbalanced. We will preprocess it. First, we will remove all the records where the consumer_complaint_narrative column is null. Next, we will remove the product Other financial service so that we have records with actual products. We will remove all the dataset columns except product and consumer_complaint_narrative.

Finally, to balance our dataset, we will select 10 records for each product, resulting in a total of 100 records. You can select more records, but remember that you will have to pay to process each record via the Anthropic and OpenAI APIs.

The following script performs data preprocessing.

#Remove rows where consumer_complaint_narrative is null
df_filtered = dataset.dropna(subset=['consumer_complaint_narrative'])

#Remove rows with "Other financial service" in the product column
df_filtered = df_filtered[df_filtered['product'] != 'Other financial service']

#Keep only the "product" and "consumer_complaint_narrative" columns
df_filtered = df_filtered[['product', 'consumer_complaint_narrative']]

#Sample 10 rows from each remaining product category
df_sampled = df_filtered.groupby('product').apply(lambda x: x.sample(10)).reset_index(drop=True)

print(df_sampled.shape)
print(df_sampled["product"].value_counts())

Output:

We can now perform zero-shot text classification with Claude 3.5 Sonnet and GPT-4o.

Zero Shot Text Classification with Claude 3.5 Sonnet

To call the Claude 3.5 Sonnet model, you must create a client object of the anthropic.Anthropic class and pass it your Anthropic API key and the Claude 3.5 Sonnet model id.

client = anthropic.Anthropic(
    api_key = os.environ.get('ANTHROPIC_API_KEY')
)

model = "claude-3-5-sonnet-20240620"

Next, we will define a script that iterates through all the records in consumer_complaint_narrative column of our sampled dataset. For each record, we will call the messages.create() function of the Anthropic client object and ask the Claude 3.5 Sonnet model to predict the product for the complaint from the list of products. The model response is appended to the predictions list.

predictions = []

complaints_list = df_sampled["consumer_complaint_narrative"].tolist()

complaint_category_list = """
Bank account or service   
Consumer Loan              
Credit card                
Credit reporting          
Debt collection            
Money transfers            
Mortgage                   
Payday loan                
Prepaid card               
Student loan               

"""
i = 0

while i < len(complaints_list):

    try:
        complaint = complaints_list[i]
        content = """You are a consumer complaint processing officer.
        For the following complaint text, select one of the complaint categories from the complaint category list.
        Return only the sentiment complaint category without any additional remarks or text.
        \n\n
        Complaint text: {}
        \n\n
        Complaint Category list {}""".format(complaint, complaint_category_list)

        prediction = client.messages.create(
                                model= model,
                                max_tokens=25,
                                temperature=0.0,
                                messages=[
                                    {"role": "user", "content": content}
                                ]
                            ).content[0].text

        predictions.append(prediction)
        i = i + 1
        print(i, prediction)

    except Exception as e:
        print("===================")
        print("Exception occurred:", e)

Finally, we compare the model predictions with the actual products to print the model accuracy.

accuracy = accuracy_score(predictions, df_sampled["product"])
print("Accuracy:", accuracy)

Output:

Accuracy: 0.65

The above output shows that the Claude 3.5 Sonnet model achieved 65% accuracy for zero-shot multiclass text classification.

Zero Shot Text Classification with GPT-4o

The process for Zero-shot text classification with GPT-4o is similar to Claude 3.5 Sonnet.

First, create a client object of the OpenAI class and pass it your OpenAI API key and GPT-4o model ID.

client = OpenAI(
    api_key = os.environ.get('OPENAI_API_KEY'),
)
model = "gpt-4o"

Next, you iterate through all the consumer complaints and make predictions for the product category using the chat.completions.create() method of the OpenAI client object. Finally, you can compare the predictions with the actual categories to calculate model accuracy.

predictions = []

i = 0

while i < len(complaints_list):

    try:
        complaint = complaints_list[i]
        content = """You are a consumer complaint processing officer.
        For the following complaint text, select one of the complaint categories from the complaint category list.
        Return only the sentiment complaint category without any additional remarks or text.
        \n\n
        Complaint text: {}
        \n\n
        Complaint Category list {}""".format(complaint, complaint_category_list)

        prediction = client.chat.completions.create(
                                  model= model,
                                  temperature = 0,
                                  max_tokens = 25,
                                  messages=[
                                        {"role": "user", "content": content}
                                    ]
                                ).choices[0].message.content

        predictions.append(prediction)
        i = i + 1
        print(i, prediction)

    except Exception as e:
        print("===================")
        print("Exception occurred:", e)

accuracy = accuracy_score(predictions, df_sampled["product"])
print("Accuracy:", accuracy)

Output:

Accuracy: 0.67

The above output shows that GPT-4o performs slightly better than Claude 3.5 sonnet for zero-shot text classification.

Next, we will compare Claude 3.5 Sonnet and GPT-4o for zero-shot text summarization.

Claude 3.5 Sonnet vs GPT-4o For Text Summarization

The comparison process for zero-shot text summarization remains similar to zero-shot text classification. However, the dataset, prompt, and evaluation criteria will change.

Importing the Dataset

We will use the CNN Daily Mail Dataset from Kaggle, which contains news articles and corresponding human-generated highlights, or summaries.

The following script imports the dataset.

##Dataset download link
##https://www.kaggle.com/datasets/gowrishankarp/newspaper-text-summarization-cnn-dailymail

dataset = pd.read_csv(r"D:\Datasets\cnn_dailymail\test.csv")
dataset = dataset.sample(frac=1)
print(dataset.shape)
dataset.head()

Output:

The article column contains the text, while the highlights column contains the corresponding highlights.

Next, we will calculate the average number of characters in all the highlights. This number will be the maximum output tokens while calling the Claude 3.5 Sonnet and GPT-4o models.

dataset['summary_length'] = dataset['highlights'].apply(len)
average_length = dataset['summary_length'].mean()
print(f"Average length of summaries: {average_length:.2f} characters")

Output:

Average length of summaries: 311.93 characters

The output shows that, on average, we have 312 characters in the highlights.

Zero-shot Text Summarization with Claude 3.5 Sonnet

As mentioned, we will define the Anthropic class as the client object.

client = anthropic.Anthropic(
    api_key = os.environ.get('ANTHROPIC_API_KEY')
)

model = "claude-3-5-sonnet-20240620"

Next, we will define the calculate_rouge() method, which accepts human-generated and model-generated highlights and returns ROUGE1, ROUGE2, and ROUGEL scores. These are common metrics used to evaluate LLMs on tasks such as text summarization and text translation.

def calculate_rouge(reference, candidate):
    scorer = rouge_scorer.RougeScorer(['rouge1', 'rouge2', 'rougeL'], use_stemmer=True)
    scores = scorer.score(reference, candidate)
    return {key: value.fmeasure for key, value in scores.items()}

Finally, we will iterate through the first 20 articles in the dataset and pass them to the Claude 3.5 Sonnet model to generate the article highlights. You can pass more articles, but, again, this costs money so we want to be prudent.

The model response, which contains the model-generated highlights and the human-generated highlights, is passed to the calculate_rouge() method. The corresponding ROUGE scores are stored in the results dictionary.

results = []

i = 0
for _, row in dataset[:20].iterrows():
    article = row['article']
    highlight = row['highlights']

    i = i + 1

    print(f"Summarizing article {i}")

    prompt = f"Create highlights of the following article in 320 characters. The highlights should look like they were human created:\n\n{article}\n\nSummary:"
    generated_summary = client.messages.create(
                                model= model,
                                max_tokens=320,
                                temperature=0.7,
                                messages=[
                                    {"role": "user", "content": prompt}
                                ]
                            ).content[0].text

    rouge_scores = calculate_rouge(highlight, generated_summary)

    results.append({
        'article_id': row.id,
        'generated_summary': generated_summary,
        'rouge1': rouge_scores['rouge1'],
        'rouge2': rouge_scores['rouge2'],
        'rougeL': rouge_scores['rougeL']
    })

To print the model performance, we convert the results dictionary into a Pandas dataframe and print the average of the rouge1, rouge2, and rouge3 columns.

results_df = pd.DataFrame(results)
average_rouge_scores = results_df[['rouge1', 'rouge2', 'rougeL']].mean()
print(f"Average ROUGE-1 Score: {average_rouge_scores['rouge1']:.4f}")
print(f"Average ROUGE-2 Score: {average_rouge_scores['rouge2']:.4f}")
print(f"Average ROUGE-L Score: {average_rouge_scores['rougeL']:.4f}")

Output:

Average ROUGE-1 Score: 0.3434
Average ROUGE-2 Score: 0.1009
Average ROUGE-L Score: 0.1907

The above output shows the ROUGE scores achieved by the Claude 3.5 Sonnet model.

Zero-shot Text Summarization with GPT-4o

Next, we will perform zero-shot text summarization using the GPT-4o model. The following script creates the OpenAI client object.

client = OpenAI(
    api_key = os.environ.get('OPENAI_API_KEY'),
)
model = "gpt-4o"

Next, we pass the first 20 articles from the dataset to the GPT-4o model to get article highlights. Finally, we evaluate the model performance using the calculate_rouge() function.

results = []

i = 0
for _, row in dataset[:20].iterrows():
    article = row['article']
    highlight = row['highlights']

    i = i + 1

    print(f"Summarizing article {i}")

    prompt = f"Create highlights of the following article in 320 characters. The highlights should look like they were human created:\n\n{article}\n\nSummary:"
    generated_summary = client.chat.completions.create(
                            model=model,
                            messages=[{"role": "user", "content": prompt}],
                            max_tokens=320,
                            temperature=0.7
                        ).choices[0].message.content

    rouge_scores = calculate_rouge(highlight, generated_summary)

    results.append({
        'article_id': row.id,
        'generated_summary': generated_summary,
        'rouge1': rouge_scores['rouge1'],
        'rouge2': rouge_scores['rouge2'],
        'rougeL': rouge_scores['rougeL']
    })

The following script prints the ROUGE scores for OpenAI GPT-4o model.

results_df = pd.DataFrame(results)
average_rouge_scores = results_df[['rouge1', 'rouge2', 'rougeL']].mean()
print(f"Average ROUGE-1 Score: {average_rouge_scores['rouge1']:.4f}")
print(f"Average ROUGE-2 Score: {average_rouge_scores['rouge2']:.4f}")
print(f"Average ROUGE-L Score: {average_rouge_scores['rougeL']:.4f}")

Output:

Average ROUGE-1 Score: 0.4120
Average ROUGE-2 Score: 0.1429
Average ROUGE-L Score: 0.2255

Final Verdict

The results in this article show that GPT-4o is a better choice for zero-shot text classification and summarization tasks. I recommend you try different prompts to see if you get different results. But for now, we’ll stick with ChatGPT for our everyday tasks.

Chatbot Development Using Meta Llama 3.1 in LangChain

Wed, 07 Aug 2024 00:00:00 -0400

On July 23, 2024, Meta released Llama 3.1, its state-of-the-art large language model. The model was released in three versions, with 8 billion, 70 billion, and 405 billion parameters.

Meta claimed that the Llama 3.1 405B model is better than GPT-4 Turbo and on par with GPT-4o in some benchmarks. As per Livebench and Chat.lmsys, the Llama 3.1 405B ranks just below Claude 3.5 sonnet, GPT-4o, and Gemini 1.5 pro. However, Llama 3.1 models are open-source, meaning you can use them for free.

In this article, we’ll show you how to use the Llama 3.1 8B model from Hugging Face to develop a chatbot using LangChain. The approach to developing a chatbot using Llama 3.1 70B or 405B remains the same.

By the end of this article, you’ll understand:

How to import an open source model such as Llama 3.1 8B from Hugging Face in LangChain.
How to call an open-source LLM in LangChain.
How to add memory to your chatbot in LangChain.

So, let’s get right to it!

Installing and Importing Required Libraries

We will use the transformers library from Hugging Face to import the Llama 3.1 model. Additionally, we’ll use the Python LangChain library as the orchestrator framework to develop our chatbot. The following script downloads the required libraries.

!pip install --upgrade transformers accelerate
!pip install -q -U sentence-transformers
!pip install -q -U huggingface_hub
!pip install -q -U langchain
!pip install langchain-community

The script below imports the required libraries in our Python application and suppresses lower level warnings.

from transformers import AutoModelForCausalLM, AutoTokenizer, logging, pipeline
from sentence_transformers import SentenceTransformer
from langchain_community.llms.huggingface_pipeline import HuggingFacePipeline
from huggingface_hub import login
from langchain_core.output_parsers import StrOutputParser
from langchain_core.prompts import ChatPromptTemplate, MessagesPlaceholder
from langchain_core.runnables.history import RunnableWithMessageHistory
from langchain.memory import ChatMessageHistory
import torch

#Ignore warnings
logging.set_verbosity(logging.CRITICAL)

Importing the Meta Llama 3.1 Model in LangChain

Before importing the Llama 3.1 model in LangChain, download it from the Hugging Face library. To do so, use the AutoModelForCausalLM class and pass your model ID to it. You will also need the tokenizer for the Llama 3.1 model, which you can download using the AutoTokenizer class, as shown in the script below. Notice the placeholder where you should place your own hugging face token, YOUR_HUGGING_FACE_TOKEN. If you’re new to Hugging Face, you can create a new token under Settings > Access Tokens.

login(token="YOUR_HUGGING_FACE_TOKEN")

model_id = "meta-llama/Meta-Llama-3.1-8B-Instruct"
device = "cuda" # the device to load the model onto
model = AutoModelForCausalLM.from_pretrained(model_id,
                                             device_map={"":0})
tokenizer = AutoTokenizer.from_pretrained(model_id)

If you run this and get a 403 Client Error (“You are trying to access a gated repo”), you’ll need to click the link in the error and agree to the terms to access the model. After accepting the agreement, your information is reviewed. This review process could take a few days, so be patient.

Next, to import the downloaded Hugging Face model in LangChain, create a pipeline class object and pass the model and tokenizer you downloaded to its constructor. If you want to develop a chatbot, the first argument to the pipeline class must be text-generation. Since I want the model to restrict the output to 300 tokens, I set the max_new_tokens value to 300.

pipe = pipeline("text-generation",
                model=model,
                tokenizer=tokenizer,
                max_new_tokens=300)

llm = HuggingFacePipeline(pipeline=pipe)

The rest of the process involves creating a LangChain prompt, the chain, and calling the invoke() method, which calls the chain using the passed prompt.

To create a chain, you can use the Lang Chain Expression Language (LCEL) that allows you to bind the prompt, the LLM model and the output parser in a single step.

Finally, call the invoke() method using the chain object and pass the query string to the chain.

The following script shows how you can get a response from the Meta Llama 3.1 model you downloaded.

template = """Answer the following question precisely and to the best of your abilities in 200 words.
Question: {Question}"""

prompt = ChatPromptTemplate.from_template(template)

output_parser = StrOutputParser()

chain = prompt | llm | output_parser

question = "How to prepare lemon juice by hand?"
response = chain.invoke({"Question": question})
print(f"\n{response}")

Output:

The above script returns a response to isolated queries and does not remember anything from the previous conversation. For chatbot creation, you’ll want an LLM to remember previous interactions so it can build on prior discussions. In the next section, we’ll show you how to create a chatbot with memory using LangChain.

Creating a Chatbot with Memory Using Open Source LLMs in LangChain

LangChain provides the ChatMessageHistory class, which you can use in conjunction with the RunnableWithMessageHistory class to implement a chain with memory.

To do so, you need to modify your template and pass it the system prompt along with a MessagesPlaceholder object containing the name of a variable that stores your chat history. In the following script, we name the variable chat_history. Additionally, you must pass the value for the variable storing human query. The following script names this variable input.

Next, you need to create an object of the ChatMessageHistory() class that will store all present and past interactions with the chatbot.

Finally, instead of calling the invoke() method directly on the chain, you need to create an object of the RunnableWithMessageHistory() class and pass it the original chain, the ChatMessageHistory object, the input_messages_key, and the history_messages_key - the latter of which are input and chat_history, respectively, as you can see in the prompt.

prompt = ChatPromptTemplate.from_messages(
    [
        (
            "system",
            "You are a helpful assistant. Answer human questions to the best of your ability in 30 words",
        ),
        MessagesPlaceholder(variable_name="chat_history"),
        ("human", "{input}"),
    ]
)

output_parser = StrOutputParser()

chain = prompt | llm | output_parser

chat_history_memory = ChatMessageHistory()

chain_with_message_history = RunnableWithMessageHistory(
    chain,
    lambda session_id: chat_history_memory,
    input_messages_key="input",
    history_messages_key="chat_history",
)

Next, we will define the return_response() function, which accepts a user query and passes it to the invoke() method of the RunnableWithMessageHistory class object (chain_with_message_history in the script below).

def return_response(user_query):


  response = chain_with_message_history.invoke(
      {"input": user_query},
      {"configurable": {"session_id": "session_1"}},
  )

  return response

To create the chatbot functionality, add a while loop that executes until a user enters bye. Inside the loop, the user enters a query, which we send to the return_response() function. Finally, we print the response on the console.

print("=======================================================================")
print("Welcome to your own Llama 3.1 Chatbot")
print("=======================================================================")

query = ""
while query != "bye":
  query = input("\033[1m User >>:\033[0m")
  response = return_response(query)
  print(f"\033[1m Chatbot>>:\033[0m {response}")

Output:

From the above output, you can see that the user question and past history are passed to the LLM in every call. You can do some post-processing to remove the question text and past history from the response.

I suggest you try Meta Llama 3.1 70B or even 405B to get better responses. However, you will need a vast GPU memory for that. In this article, I used Nvidia A100 with 40 GB GPU memory to get responses from the Meta Llama 3.1 8B model.

Conclusion

Open-source models are quickly catching up with proprietary models like Chat-GPT and Claude. What makes open-source models attractive is that you have the source code and don’t have to pay to get responses from them.

In this article, you saw how to create a simple chatbot, free of cost, using the Meta Llama 3.1 8B model. If you have the hardware to support it, try Llama 3.1 70B and 405B models and see if you get better results.

The Python Tutorials Blog

Building a MySQL Agent in Python LangGraph Framework

Installing and Importing Required Libraries

Creating a MySQL Connection and Retrieving DB Information

Importing LangChain Database Tools

Creating MySQL Agent using LangGraph Default ReAct Agent

Creating a Customized MySQL Agent with LangGraph

Developing a Simple Login Page with Python Django Framework

Installing Django and Creating a Django Project

Creating the Login App

Creating URLs

Creating Views

Creating Templates

Registering Routes

Creating Users and Testing the Application

Conclusion

Extracting Structured Data Using LLMs via Hugging Face API

Importing and Installing Required Libraries

Basic Example of Extracting Structured Data

Define the Structured Response Format

Define the Query for Structured Response

Call an LLM From Hugging Face Inference API

Extracting Structured Data from News Articles - A Real-world Example

Importing the Dataset

Extracting Structured Data from a Single News Article

Extracting Structured Data from Multiple News Articles

Visualizing Structured Data

Multiagent Workflow in LangGraph with DeepSeek R1 Model

Installing and Importing Required Libraries

Data Ingestion into Vector Database For RAG

Creating a Multiagent Workflow in RAG

Defining State and Router Node

Defining RAG Nodes

Defining Tabular Data Node

Putting it All Together

Conclusion

Retrieval Augmented Generation with LangGraph Agents

Installing and Importing Required Libraries

Data Ingestion into Vector Database

Data Retrieval

Response Generation

Putting It All Together: Creating a RAG LangGraph Agent

Going Further: Adding Memory to Conversations

Conclusion

How to Develop Multi-agent Chatbots with LangGraph Agents

Installing and Importing Required Libraries

Defining Tools

Creating a Multi-agent LangGraph

Creating a Router for Query Classification

Creating Nodes to add in LangGraph

Adding Nodes and Compiling the Graph

Conclusion

YouTube Chatbot in LangChain Using Alibaba Qwen 2.5 Model

Installing and Importing Required Libraries

Importing Qwen 2.5 LLM from Hugging Face in LangChain

Retrieval Augmented Generation with Qwen 2.5 in LangChain

Generating Embeddings from YouTube Videos

Creating Chatbot Response Based on Documents

Conclusion

Time Series Prediction with Hugging Face Transformers

Installing and Importing Required Libraries

Importing and Preprocessing Stock Market Data

Importing Chronos Time Series Model Making Predictions using

Conclusion

Anthropic Claude 3.5 Sonnet - Is it better than ChatGPT?

Importing and Installing Required Libraries

Claude 3.5 Sonnet vs GPT-4o For Text Classification

Importing and Preprocessing the Dataset

Zero Shot Text Classification with Claude 3.5 Sonnet

Zero Shot Text Classification with GPT-4o

Claude 3.5 Sonnet vs GPT-4o For Text Summarization

Importing the Dataset

Zero-shot Text Summarization with Claude 3.5 Sonnet

Zero-shot Text Summarization with GPT-4o

Final Verdict

Chatbot Development Using Meta Llama 3.1 in LangChain

Installing and Importing Required Libraries

Importing the Meta Llama 3.1 Model in LangChain

Creating a Chatbot with Memory Using Open Source LLMs in LangChain

Conclusion