ADVANCED Python AI Agent Tutorial - Using RAG, Langflow & Multi-Agents

Key Concepts

• Multi AI Agent Application: A system combining multiple AI agents to solve complex tasks.
• Lang Flow: A drag-and-drop visual editor for building AI applications.
• Rank Retrieval, Augmented Generation (RAG): A technique to enhance AI responses by retrieving relevant information from a database and incorporating it into the prompt.
• Vector Database: A database that stores data as vectors, enabling similarity searches for contextually relevant information.
• Astra DB: A vector-enabled database provided by Data Stacks.
• Agents: AI entities that can perform specific tasks using tools.
• Tools: Specific functionalities or resources that agents can utilize.
• Streamlit: A Python library for creating interactive web applications.

Building a Multi AI Agent Application with Lang Flow

Introduction

The video demonstrates how to build a multi AI agent application using Lang Flow, focusing on creating a customer support agent capable of accessing orders, checking shipment status, retrieving product information, and answering frequently asked questions.

Demo of the Customer Support Agent

The demo showcases a customer support agent built with Lang Flow that can:

• Access order information from a database (e.g., order number, status, pricing).
• Look up products in the database.
• Answer frequently asked questions using rank retrieval.
• The agent is integrated into a simple Streamlit application for a user-friendly interface.

Lang Flow Overview

• Lang Flow is a drag-and-drop editor that allows users to combine different components to build advanced AI systems.
• It is open-source and free to use.
• Flows can be exported and imported as JSON files.

Building a Simple AI Agent with RAG

1. Input: Start with a chat input component to allow users to type in their questions.
2. Agent: Use an agent component, specifying the model (e.g., OpenAI) and API key.
3. Prompt: Create a prompt component to provide instructions to the agent.
   • Example prompt: "Your primary goal is to accurately answer user questions by utilizing information from the company database. Use retrieval, augmented generation to fetch and present the most relevant data."
   • Use variables within the prompt (e.g., {question}, {results}) to dynamically insert user input and database results.
4. Vector Store (Astra DB):
   • Create a free account with Data Stacks and create a new Astra DB database and a vector-enabled collection.
   • Configure the Astra DB component in Lang Flow with the database and collection details.
   • Set the embedding model to Astra Vectorize and the embedding provider to Nvidia with the NV embed QA model.
   • Connect the chat input to the search input of the Astra DB component.
5. Parse Data: Use a parse data component to convert the search results (JSON) into textual data.
6. Output: Connect the agent's response to a chat output component.

Adding Data to the Vector Database

1. File Input: Use a file component to upload a PDF document (e.g., a FAQ document).
2. Split Text: Connect the file component to a split text component to chunk the document into smaller pieces.
3. Astra DB (Ingest Data):
   • Connect the split text component to an Astra DB component configured to ingest data into the database.
   • Use the same database, collection, and embedding model settings as before.
4. Run the Flow: Run the Astra DB component to add the PDF data to the database.

Converting the Agent into a Tool

1. Enable "Tool Mode" on the FAQ agent. This removes the direct input and output, making it usable by other agents.
2. Provide an agent description to inform other agents about its functionality (e.g., "Looks up and answers frequently asked questions like shipping estimates, cancellation orders and more common business questions.").

Combining Multiple AI Agents

1. Manager Agent: Create a new agent to act as a manager, responsible for routing requests to the appropriate tool.
2. Connect Tools: Connect the FAQ agent (now a tool) to the manager agent's tools input.
3. Agent Instructions: Provide instructions to the manager agent, specifying its role and the available tools (e.g., "You're a skilled customer service manager and information router. Your primary responsibility is to use the available tools to accurately address user inquiries and provide detailed, helpful responses.").

Building an Order Lookup Agent

1. Create Collections: In Astra DB, create two new collections: "orders" and "products".
2. Load Sample Data: Load sample data (CSV files) into the "orders" and "products" collections. The "orders" collection should contain an array of product IDs.
3. Order Lookup Agent: Create a new agent and enable "Tool Mode".
4. Agent Description: Provide a description (e.g., "You can look up order and product information.").
5. Agent Instructions: Provide instructions to the order lookup agent, specifying how to retrieve order details, look up product information, and aggregate the data.
6. Astra DB Tools:
   • Add two Astra DB tools: one for looking up orders and one for looking up products.
   • Configure each tool with the appropriate database, collection, and tool parameters.
     • Order Lookup: Tool name: "order lookup", Description: "A tool used to look up and order based on its ID.", Tool Parameter: !order number
     • Product Lookup: Tool name: "product lookup", Description: "Lookup a product based on its ID.", Tool Parameter: !product ID
7. Connect Tools: Connect the order lookup agent to the manager agent's tools input.

Creating a Custom Front End with Streamlit

1. Install Modules: Install the necessary Python modules: requests, streamlit, and python-dotenv.
2. API Key: Generate an API key from Lang Flow and store it in a .env file.
3. Python Code:
   • Import the required modules (os, requests, streamlit, json, load_dotenv).
   • Load the API key from the .env file.
   • Define a run_flow function to call the Lang Flow API with a given message.
   • Define a main function to create the Streamlit UI:
     • Create a title.
     • Create a text area for user input.
     • Create a button to trigger the flow.
     • Call the run_flow function when the button is pressed.
     • Parse the response from the API and display the result in the UI.
4. Run the App: Run the Streamlit app using the command streamlit run main.py.

Retrieval Weighting

• Consider using retrieval weighting techniques to improve the accuracy of RAG systems.
• Refer to the article "Beyond Basic Rank Retrieval Weighting" for more information.

Conclusion

The video provides a comprehensive guide to building a multi AI agent application using Lang Flow. By combining different agents and tools, it is possible to create complex systems that can solve real-world business use cases. The use of RAG and vector databases allows for contextually relevant responses, while Streamlit provides a user-friendly interface for interacting with the application.