introduction

Author: ashpreetbedi

agents/memory.mdx

@@ -4,7 +4,7 @@ title: Memory
 
 If you're building intelligent agents, you need to give them memory **which is their ability to learn about the user they are interacting with**. Memory comes in 3 shapes:
 
-1. **Session Storage:** Session storage saves sessions in a database and enables Agents to have multi-turn conversations. Session storage also holds the session state, which is persistent across runs because it is saved to the database after each run. Session storage is a form of short-term memory **called "Storage" in Agno**.
+1. **Session Storage:** Session storage saves sessions in a database and enables Agents to have multi-turn conversations. Session storage also holds the session state, which is persisted across runs because it is saved to the database after each run. Session storage is a form of short-term memory **called "Storage" in Agno**.
 
 2. **User Memories:** The Agent can also store insights and facts about the user it learns over time. This helps the agents personalize its response to the user it is interacting with. Think of this as adding "ChatGPT like memory" to your agent. **This is called "Memory" in Agno**.
 

agents/storage.mdx

@@ -6,7 +6,7 @@ title: Storage
 
 Agents come with built-in memory but it only lasts while the session is active.
 
-To persist history and state across runs, we can provide `AgentStorage` which saves an Agent's session to a database or file. Storage has typically been an under-discussed part of agentic infrastructure, but we see it as one of the most critical pieces of the stack.
+To persist session history and state across runs, we can provide `AgentStorage` which saves an Agent's session to a database or file. Storage has typically been an under-discussed part of agentic infrastructure, but we see it as one of the most critical pieces of the stack.
 
 While storage is absolutely necessary when building user facing AI products as any production application will need to be able to retrieve sessions, continue sessions, and save state between runs. There is so much more:
 - Storage saves our Agent's session data for inspection and evaluations.

introduction/agents.mdx

@@ -167,7 +167,7 @@ Set `debug_mode=True` or `export AGNO_DEBUG=true` to see the system prompt, user
 
 ## Agent with reasoning
 
-Agents can also **"think" & "reason"** to solve problems that require more than one step. The `ReasoningTools` is one of the best "hacks" to improve the Agents's response quality.
+Agents can also **"think" & "analyze"** to solve problems that require more than one step. The `ReasoningTools` is one of the best "hacks" to improve the Agents's response quality.
 
 ```python agent_with_reasoning.py
 from agno.agent import Agent

knowledge/introduction.mdx

@@ -2,7 +2,19 @@
 title: Introduction
 ---
 
-A **knowledge base** is a database of information that an agent can search to improve its responses. This information is stored in a vector database and provides agents with business context, helping them respond in a context-aware manner. The general syntax is:
+**Knowledge** is domain-specific information that the Agent can **search** at runtime to make better decisions (dynamic few-shot learning) or provide accurate responses (agentic RAG). Knowledge is stored in a vector db and this **searching on demand** pattern is known as Agentic RAG.
+
+<Accordion title="Dynamic Few-Shot Learning: Text2Sql Agent" icon="database">
+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.
+</Accordion>
+
+**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 simplest example of how to add knowledge to an Agent is:
 
 ```python
 from agno.agent import Agent, AgentKnowledge
@@ -18,6 +30,24 @@ knowledge_base.load_text("The sky is blue")
 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.
+
+<Tip>
+
+If you need complete control over the knowledge base search, you can pass your own `retriever` function with the following signature:
+
+```python
+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.
+
+</Tip>
+
 ## 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:

memory/introduction.mdx

@@ -4,18 +4,130 @@ title: Introduction
 
 # Memory for Agents
 
-If you're building intelligent agents, you need to give them memory which is the ability to **remember**, **reason** and **personalize** responses to users. Memory comes in 3 shapes:
+If you're building intelligent agents, you need to give them memory **which is their ability to learn about the user they are interacting with**. Memory comes in 3 shapes:
 
-1. **Chat History:** This is the current conversation between users and the agent, stored as sessions in chronological order. This is the most basic form of memory and **called "Storage" in Agno**.
-2. **User Memories:** Insights and facts about users extracted from conversations, helping agents personalize their responses to users. Think of this as adding a "ChatGPT like memory" to your agent. **This is called "Memory" in Agno**.
-3. **Session Summaries:** Condensed representations of conversations, useful when chat histories grow too long. **This is called "Summary" in Agno**.
+1. **Session Storage:** Session storage saves sessions in a database and enables Agents to have multi-turn conversations. Session storage also holds the session state, which is persisted across runs because it is saved to the database after each run. Session storage is a form of short-term memory **called "Storage" in Agno**.
+
+2. **User Memories:** The Agent can also store insights and facts about the user it learns over time. This helps the agents personalize its response to the user it is interacting with. Think of this as adding "ChatGPT like memory" to your agent. **This is called "Memory" in Agno**.
+
+3. **Session Summaries:** The Agent can store a condensed representations of the session, useful when chat histories gets too long. **This is called "Summary" in Agno**.
 
 Memory helps Agents:
- - Manage conversation state (chat history)
- - Personalize responses to users (user memories)
- - Maintain long-session context (session summaries)
+ - Manage session history and state (session storage).
+ - Personalize responses to users (user memories).
+ - Maintain long-session context (session summaries).
+
+## Managing User Memory
+
+When we speak about Memory, the commonly agreed upon understanding of Memory is the ability to store insights and facts about the user the Agent is interacting with. In short, build a persona of the user, learn about their preferences and use that to personalize the Agent's response.
+
+### Agentic Memory
+
+Agno Agents natively support Agentic Memory Management and recommend it as the best way to give Agents memory.
+
+With Agentic Memory, The Agent itself creates, updates and deletes memories from user conversations.
+
+Set `enable_agentic_memory=True` to enable Agentic Memory.
+
+```python agentic_memory.py
+from agno.agent.agent import Agent
+from agno.memory.v2.db.sqlite import SqliteMemoryDb
+from agno.memory.v2.memory import Memory
+from agno.models.openai import OpenAIChat
+from rich.pretty import pprint
+
+memory_db = SqliteMemoryDb(table_name="memory", db_file="tmp/memory.db")
+# No need to set the model, it gets set to the model of the agent
+memory = Memory(db=memory_db, delete_memories=True, clear_memories=True)
+
+# Reset the memory for this example
+memory.clear()
+
+# User ID for the memory
+john_doe_id = "[email protected]"
+agent = Agent(
+    model=OpenAIChat(id="gpt-4o-mini"),
+    memory=memory,
+    enable_agentic_memory=True,
+)
+
+# Send a message to the agent that would require the memory to be used
+agent.print_response(
+    "My name is John Doe and I like to hike in the mountains on weekends.",
+    stream=True,
+    user_id=john_doe_id,
+)
+
+# Send a message to the agent that checks the memory is working
+agent.print_response("What are my hobbies?", stream=True, user_id=john_doe_id)
+
+# Print the memories for the user
+memories = memory.get_user_memories(user_id=john_doe_id)
+print("Memories about John Doe:")
+pprint(memories)
+
+# Send a message to the agent that removes all memories for the user
+agent.print_response(
+    "Remove all existing memories of me.",
+    stream=True,
+    user_id=john_doe_id,
+)
+memories = memory.get_user_memories(user_id=john_doe_id)
+print("Memories about John Doe:")
+pprint(memories)
+```
+
+### Create Memories after each run
 
-Memory is critical for personal assistants, it allows Agents to "Remember" and "Personalize" their responses to users. Learn more about agent memory [here](/agents/memory) and about managing sessions [here](/agents/sessions).
+Set `enable_user_memories=True` to trigger the `MemoryManager` after each run. We recommend using Agentic Memory but this option is there is you need it.
+
+```python create_memories_after_each_run.py
+from agno.agent.agent import Agent
+from agno.memory.v2.db.sqlite import SqliteMemoryDb
+from agno.memory.v2.memory import Memory
+from agno.models.openai import OpenAIChat
+from rich.pretty import pprint
+
+memory_db = SqliteMemoryDb(table_name="memory", db_file="tmp/memory.db")
+# No need to set the model, it gets set to the model of the agent
+memory = Memory(db=memory_db, delete_memories=True, clear_memories=True)
+
+# Reset the memory for this example
+memory.clear()
+
+# User ID for the memory
+john_doe_id = "[email protected]"
+agent = Agent(
+    model=OpenAIChat(id="gpt-4o-mini"),
+    memory=memory,
+    enable_user_memories=True,
+)
+
+# Send a message to the agent that would require the memory to be used
+agent.print_response(
+    "My name is John Doe and I like to hike in the mountains on weekends.",
+    stream=True,
+    user_id=john_doe_id,
+)
+
+# Send a message to the agent that checks the memory is working
+agent.print_response("What are my hobbies?", stream=True, user_id=john_doe_id)
+
+# Print the memories for the user
+memories = memory.get_user_memories(user_id=john_doe_id)
+print("Memories about John Doe:")
+pprint(memories)
+
+# Send a message to the agent that removes all memories for the user
+agent.print_response(
+    "Remove all existing memories of me.",
+    stream=True,
+    user_id=john_doe_id,
+)
+memories = memory.get_user_memories(user_id=john_doe_id)
+print("Memories about John Doe:")
+pprint(memories)
+```
 
 ## Memory Architecture
 
@@ -35,16 +147,8 @@ memory_db = SqliteMemoryDb(table_name="memory", db_file="memory.db")
 memory = Memory(db=memory_db)
 ```
 
-## Managing Memory
-
-The core `Memory` class orchestrates all memory-related operations.
+### Adding a new memory
 
-### User Memories
-
-The `UserMemory` class represents individual facts or insights about users.
-
-
-#### Adding a new memory
 ```python
 from agno.memory.v2.memory import Memory
 from agno.memory.v2.schema import UserMemory
@@ -61,7 +165,8 @@ memory_id = memory.add_user_memory(
 )
 ```
 
-#### Updating a memory
+### Updating a memory
+
 ```python
 from agno.memory.v2.memory import Memory
 from agno.memory.v2.schema import UserMemory
@@ -70,7 +175,9 @@ memory = Memory()
 
 # Replace a user memory
 memory_id = memory.replace_user_memory(
+    # The id of the memory to replace
     memory_id=previous_memory_id,
+    # The new memory to replace it with
     memory=UserMemory(
         memory="The user's name is Verna Doe",
         topics=["personal", "name"]
@@ -79,7 +186,8 @@ memory_id = memory.replace_user_memory(
 )
 ```
 
-#### Deleting a memory
+### Deleting a memory
+
 ```python
 from agno.memory.v2.memory import Memory
 
@@ -89,10 +197,6 @@ memory = Memory()
 memory.delete_user_memory(user_id="[email protected]", memory_id=memory_id)
 ```
 
-## Agentic Memory
-
-You can use a model to create memories from user information or conversations.
-
 ### Creating memories from user information
 
 ```python

memory/storage.mdx

@@ -4,7 +4,11 @@ title: Storage
 
 # Memory Storage
 
-Agno's memory system provides persistent storage options to ensure memories are retained across application restarts. This is critical for production applications where users expect consistent experiences over time.
+To persist memories across sessions and application restarts, store memories in a persistent storage like a database.
+
+If you're using Memory in production, persistent storage is critical as you'd want to retain user memories across application restarts.
+
+Agno's memory system supports multiple persistent storage options.
 
 ## Storage Options
 
@@ -115,14 +119,14 @@ from agno.storage.sqlite import SqliteStorage
 
 # Create memory storage
 memory_db = SqliteMemoryDb(
-    table_name="memories", 
+    table_name="memories",
     db_file="tmp/memory.db"
 )
 memory = Memory(db=memory_db)
 
 # Create agent storage
 agent_storage = SqliteStorage(
-    table_name="agent_sessions", 
+    table_name="agent_sessions",
     db_file="tmp/agent_storage.db"
 )
 

models/introduction.mdx

@@ -2,9 +2,7 @@
 title: Introduction
 ---
 
-Language Models are machine-learning programs that are trained to understand natural language and code. They provide reasoning and planning capabilities to Agents.
-
-Use any `model` with an `Agent` like:
+Language Models are machine-learning programs that are trained to understand natural language and code. They act as the **brain** of the Agent - helping it reason, act, and respond to the user. Better the model, smarter the Agent.
 
 ```python
 from agno.agent import Agent

reasoning/introduction.mdx

@@ -2,7 +2,7 @@
 title: Introduction
 ---
 
-Reasoning is the ability to **think and validate** before responding or taking action.
+**Reasoning** gives Agents the ability to "think" before responding and "analyze" the results of their actions (i.e. tool calls), greatly improving the Agents' ability to solve problems that require sequential tool calls.
 
 Reasoning Agents go through an internal chain of thought before responding, working through different ideas, validating and correcting as needed. Agno supports 3 approaches to reasoning:
 1. [Reasoning Models](#reasoning-models)
@@ -35,7 +35,7 @@ Read more about reasoning models in the [Reasoning Models Guide](/reasoning/reas
 
 ## Reasoning Model + Response Model
 
-What if we wanted to use a Reasoning Model to reason but a different model to generate the response? It is well known that reasoning models are great at solving problems but not that great at responding in a natural way (like claude sonnet or gpt-4.5).
+What if we wanted to use a Reasoning Model to reason but a different model to generate the response? It is well known that reasoning models are great at solving problems but not that great at responding in a natural way (like claude sonnet or gpt-4o).
 
 By using a separate model for reasoning and a different model for responding, we can have the best of both worlds.
 
@@ -65,37 +65,34 @@ The research was first published by Anthropic in [this blog post](https://www.an
 
 ### Example
 
-```python claude_reasoning_tools.py
-from textwrap import dedent
-
+```python claude_thinking_tools.py
 from agno.agent import Agent
 from agno.models.anthropic import Claude
 from agno.tools.thinking import ThinkingTools
 from agno.tools.yfinance import YFinanceTools
 
-thinking_agent = Agent(
-    model=Claude(id="claude-3-7-sonnet-20250219"),
+reasoning_agent = Agent(
+    model=Claude(id="claude-3-7-sonnet-latest"),
     tools=[
-        ThinkingTools(),
-        YFinanceTools(stock_price=True, analyst_recommendations=True, company_info=True, company_news=True),
+        ThinkingTools(add_instructions=True),
+        YFinanceTools(
+            stock_price=True,
+            analyst_recommendations=True,
+            company_info=True,
+            company_news=True,
+        ),
     ],
-    instructions=dedent("""\
-    ## Using the think tool
-    Before taking any action or responding to the user after receiving tool results, use the think tool as a scratchpad to:
-    - List the specific rules that apply to the current request
-    - Check if all required information is collected
-    - Verify that the planned action complies with all policies
-    - Iterate over tool results for correctness
-
-    ## Rules
-    - Its expected that you will use the think tool generously to jot down thoughts and ideas.
-    - Use tables where possible\
-    """),
-    show_tool_calls=True,
-)
-thinking_agent.print_response(
-    "Write a report comparing NVDA to TSLA", stream=True, markdown=True
+    instructions="Use tables where possible",
+    markdown=True,
 )
+
+if __name__ == "__main__":
+    reasoning_agent.print_response(
+        "Write a report on NVDA. Only the report, no other text.",
+        stream=True,
+        show_full_reasoning=True,
+        stream_intermediate_steps=True,
+    )
 ```
 
 Read more about reasoning tools in the [Reasoning Tools Guide](/reasoning/reasoning-tools).