What is Knowledge?

Knowledge is domain-specific information that the Agent can search at runtime to make better decisions (dynamic few-shot learning) and provide accurate responses (agentic RAG).

Knowledge is stored in a vector db and this searching on demand pattern is called Agentic RAG.

Dynamic Few-Shot Learning: Text2Sql Agent

Example: If we’re building a Text2Sql Agent, we’ll need to give the table schemas, column names, data types, example queries, common “gotchas” to help it generate the best-possible SQL query.

We’re obviously not going to put this all in the system prompt, instead we store this information in a vector database and let the Agent query it at runtime.

Using this information, the Agent can then generate the best-possible SQL query. This is called dynamic few-shot learning.

Agno Agents use Agentic RAG by default, meaning if you add knowledge to an Agent, it will search this knowledge base, at runtime, for the specific information it needs to achieve its task.

The pseudo steps for adding knowledge to an Agent are:

from agno.agent import Agent, AgentKnowledge

# Create a knowledge base for the Agent
knowledge_base = AgentKnowledge(vector_db=...)

# Add information to the knowledge base
knowledge_base.load_text("The sky is blue")

# Add the knowledge base to the Agent and
# give it a tool to search the knowledge base as needed
agent = Agent(knowledge=knowledge_base, search_knowledge=True)

We can give our agent access to the knowledge base in the following ways:

• We can set search_knowledge=True to add a search_knowledge_base() tool to the Agent. search_knowledge is True by default if you add knowledge to an Agent.
• We can set add_references=True to automatically add references from the knowledge base to the Agent’s prompt. This is the traditional 2023 RAG approach.

If you need complete control over the knowledge base search, you can pass your own retriever function with the following signature:

def retriever(agent: Agent, query: str, num_documents: Optional[int], **kwargs) -> Optional[list[dict]]:
  ...

This function is called during search_knowledge_base() and is used by the Agent to retrieve references from the knowledge base. For more details check out the Custom Retriever page.

Vector Databases

While any type of storage can act as a knowledge base, vector databases offer the best solution for retrieving relevant results from dense information quickly. Here’s how vector databases are used with Agents:

1. Chunk the information

   Break down the knowledge into smaller chunks to ensure our search query returns only relevant results.

2. Load the knowledge base

   Convert the chunks into embedding vectors and store them in a vector database.

3. Search the knowledge base

   When the user sends a message, we convert the input message into an embedding and “search” for nearest neighbors in the vector database.

Loading the Knowledge Base

Before you can use a knowledge base, it needs to be loaded with embeddings that will be used for retrieval.

Asynchronous Loading

Many vector databases support asynchronous operations, which can significantly improve performance when loading large knowledge bases. You can leverage this capability using the aload() method:

import asyncio

from agno.agent import Agent
from agno.knowledge.pdf import PDFKnowledgeBase, PDFReader
from agno.vectordb.qdrant import Qdrant

COLLECTION_NAME = "pdf-reader"

vector_db = Qdrant(collection=COLLECTION_NAME, url="http://localhost:6333")

# Create a knowledge base with the PDFs from the data/pdfs directory
knowledge_base = PDFKnowledgeBase(
    path="data/pdf",
    vector_db=vector_db,
    reader=PDFReader(chunk=True),
)

# Create an agent with the knowledge base
agent = Agent(
    knowledge=knowledge_base,
    search_knowledge=True,
)

if __name__ == "__main__":
    # Comment out after first run
    asyncio.run(knowledge_base.aload(recreate=False))

    # Create and use the agent
    asyncio.run(agent.aprint_response("How to make Thai curry?", markdown=True))

Using aload() ensures you take full advantage of the non-blocking operations, concurrent processing, and reduced latency that async vector database operations offer. This is especially valuable in production environments with high throughput requirements.

For more details on vector database async capabilities, see the Vector Database Introduction.

Use one of the following knowledge bases to simplify the chunking, loading, searching and optimization process:

• ArXiv knowledge base: Load ArXiv papers to a knowledge base
• Combined knowledge base: Combine multiple knowledge bases into 1
• CSV knowledge base: Load local CSV files to a knowledge base
• CSV URL knowledge base: Load CSV files from a URL to a knowledge base
• Document knowledge base: Load local docx files to a knowledge base
• JSON knowledge base: Load JSON files to a knowledge base
• LangChain knowledge base: Use a Langchain retriever as a knowledge base
• PDF knowledge base: Load local PDF files to a knowledge base
• PDF URL knowledge base: Load PDF files from a URL to a knowledge base
• S3 PDF knowledge base: Load PDF files from S3 to a knowledge base
• S3 Text knowledge base: Load text files from S3 to a knowledge base
• Text knowledge base: Load text/docx files to a knowledge base
• Website knowledge base: Load website data to a knowledge base
• Wikipedia knowledge base: Load wikipedia articles to a knowledge base

Assistant

Responses are generated using AI and may contain mistakes.