[Launched] Generally Available: User Groups and IP address pools for P2S connections
May 22, 2026Imagine interacting with an AI assistant that remembers your preferences – the tools you use, the projects you’re working on, or even how you like your coffee. In many AI systems today, maintaining this kind of long-term memory isn’t straightforward. While models can understand context within a single conversation, remembering important information across multiple interactions requires additional infrastructure.
That’s exactly the problem Memory Store in Microsoft Foundry is designed to solve.
In this blog, we’ll:
- Understand what Memory Store is
- See why it’s powerful for real-world agents
- Build a tiny but cool demo with Python
What Is Memory Store in Microsoft Foundry?
Memory Store (preview) in Foundry Agent Service is a managed, long‑term memory system for your AI agents.
In simple terms:
Your agent can remember things across conversations, sessions, and even devices.
It’s not just chat history, it’s structured memory that can store:
- User preferences
- Important facts
- Summarized conversation context
Memory Store enables agent continuity and personalization while keeping memories secure and scoped per user.
Key Concepts
Memory Store
- Its a container where memories live. Memory stores act as persistent storage, defining which types of information are relevant to each agent.
- Best practice: Create one memory store per agent to keep memory boundaries clean and retrieval efficient.
Scope
Defines who the memory belongs to.
- Can be a custom ID (user_123)
- Or auto-mapped using {{$userId}} from authentication headers
This ensures privacy and isolation by design.
Think of it as saying: “This memory belongs only to this user, not everyone.”
Memory Types
- User profile memory
This captures stable, long‑term user information, such as:
- Preferences (e.g., dark roast coffee)
- Habits
- Repeated choices
- These memories are injected as static context at the start of a conversation.
- Chat summary memory
This captures condensed insights from conversations.
Now that we understand the core concepts, let’s see Memory Store in action. We’ll build a simple agent that remembers a user’s coffee preference and recalls it in a later conversation.
Mini Demo: Teaching an Agent to Remember
We’ll create:
- A memory store
- An agent with memory
- A conversation where the agent learns something
- A new conversation where it remembers it
Prerequisites (Quick Checklist)
You’ll need:
- An Azure subscription
- A Microsoft Foundry project
- Deployed models:
- chat deployment model like gpt-4.1 or similar
- text-embedding-3-small (embeddings)
- Python 3.8+
Environment Setup
First, install the required dependencies: pip install azure-ai-projects azure-identity openai python-dotenv
Create a .env file with your Azure AI Projects connection string: FOUNDRY_PROJECT_ENDPOINT=your_connection_string_here
Here’s the full implementation that creates a memory-enabled coffee agent:
import os
import time
from dotenv import load_dotenv
from azure.ai.projects import AIProjectClient
from azure.ai.projects.models import (
MemoryStoreDefaultDefinition,
MemoryStoreDefaultOptions,
MemorySearchPreviewTool,
PromptAgentDefinition,
)
from azure.identity import DefaultAzureCredential
# —————————————————
# Load environment variables
# —————————————————
load_dotenv()
FOUNDRY_PROJECT_ENDPOINT = os.getenv(“FOUNDRY_PROJECT_ENDPOINT”)
if not FOUNDRY_PROJECT_ENDPOINT:
raise ValueError(“FOUNDRY_PROJECT_ENDPOINT not set in .env file”)
# —————————————————
# Create Foundry Project Client
# —————————————————
project_client = AIProjectClient(
endpoint=FOUNDRY_PROJECT_ENDPOINT,
credential=DefaultAzureCredential(),
)
openai_client = project_client.get_openai_client()
# —————————————————
# STEP 1: Create Memory Store
# —————————————————
print(“Creating memory store…”)
options = MemoryStoreDefaultOptions(
chat_summary_enabled=True,
user_profile_enabled=True,
user_profile_details=”Avoid sensitive data like age, finance, or credentials”,
)
definition = MemoryStoreDefaultDefinition(
chat_model=”gpt-4.1″,
embedding_model=”text-embedding-3-small”,
options=options,
)
# Try to create memory store, or get existing one if it already exists
try:
memory_store = project_client.beta.memory_stores.create(
name=”coffee_memory_store”,
definition=definition,
description=”Memory store for coffee preferences”,
)
print(f”✅ Memory store created: {memory_store.name}”)
except Exception as e:
if “already exists” in str(e):
print(“Memory store already exists, using existing one…”)
# Get the existing memory store
memory_stores = project_client.beta.memory_stores.list()
memory_store = None
for store in memory_stores:
if store.name == “coffee_memory_store”:
memory_store = store
break
if memory_store:
print(f”✅ Using existing memory store: {memory_store.name}”)
else:
print(“❌ Could not find existing memory store”)
raise e
else:
raise e
# —————————————————
# STEP 2: Create Agent with Memory
# —————————————————
print(“Creating agent with memory…”)
memory_tool = MemorySearchPreviewTool(
memory_store_name=”coffee_memory_store”,
scope=”user_123″,
update_delay=1,
)
# Try to create agent, or get existing one if it already exists
try:
agent = project_client.agents.create_version(
agent_name=”CoffeeAgent”,
definition=PromptAgentDefinition(
model=”gpt-4.1″,
instructions=”You are a helpful coffee assistant with memory. You can remember customer preferences and order history across conversations. When a customer mentions their preferences, remember them for future orders.”,
tools=[memory_tool],
),
)
print(f”✅ Agent created: {agent.name}”)
except Exception as e:
if “already exists” in str(e) or “Agent with name” in str(e):
print(“Agent already exists, using existing one…”)
# Get the existing agent
agents = project_client.agents.list_versions(agent_name=”CoffeeAgent”)
if agents:
agent = agents[0] # Use the first/latest version
print(f”✅ Using existing agent: {agent.name}”)
else:
print(“❌ Could not find existing agent”)
raise e
else:
raise e
# —————————————————
# STEP 3: First Conversation (Learning)
# —————————————————
print(“Starting first conversation…”)
conversation = openai_client.conversations.create()
response = openai_client.responses.create(
input=”I prefer dark roast coffee”,
conversation=conversation.id,
extra_body={
“agent_reference”: {
“name”: agent.name,
“type”: “agent_reference”,
}
},
)
print(“🧠 Agent response:”, response.output_text)
print(“Waiting for memory to be stored…”)
time.sleep(65) # allow debounce + memory write
# —————————————————
# STEP 4: New Conversation (Recall)
# —————————————————
print(“Starting new conversation…”)
new_conversation = openai_client.conversations.create()
new_response = openai_client.responses.create(
input=”Order my usual coffee”,
conversation=new_conversation.id,
extra_body={
“agent_reference”: {
“name”: agent.name,
“type”: “agent_reference”,
}
},
)
print(“☕ Agent response:”, new_response.output_text)
print(“🎉 Memory recall successful!”)
Output:
Verifying in Microsoft Foundry
You can also test and verify the memory functionality directly in the Microsoft Foundry:
- Navigate to your CoffeeAgent in the Foundry portal interface
- Open the **Memory** section — confirm “coffee_memory_store” is connected
- Use the Chat interface and ask: “What coffee do I prefer?”
- View the response – the agent will correctly recall your dark roast preference
Key Implementation Points
- Consistent Scoping: Use consistent user scope in memory tools for proper context association
- Resource Management: Handle existing resources gracefully for reusable code
- Memory Processing: Allow sufficient time for memory processing between conversations
- Agent Instructions: Include memory capabilities in agent instructions for better performance
Customization Options
You can customize the memory store for different use cases:
- Change memory scope: Use different user IDs for multi-user applications
- Update agent instructions: Tailor personality and memory usage patterns
- Configure update delays: Adjust ‘update_delay’ in the sample code based on your performance needs
Next Steps & Resources
If you want to take this further, here are a few ways to continue exploring Memory Store:
- What is Memory in Microsoft Foundry? : What is Memory? – Microsoft Foundry | Microsoft Learn
- Create and use Memory Store : Create and Use Memory – Microsoft Foundry | Microsoft Learn
- Microsoft Foundry documentation (agents, tools, APIs) :Microsoft Foundry documentation | Microsoft Learn
Try It Yourself
Take this demo further by:
– Storing multiple preferences (drink, time, location)
– Using dynamic scopes ({{$userId}}) for multi‑user applications
– Observing how memory evolves across multiple conversations and sessions
Build Ideas
Here are a few practical use cases to extend this pattern:
– Personalized onboarding assistant that remembers user preferences
– Smart recommendation engine (food, tools, learning paths)
– Customer support agent with long-term context and conversation continuity
By combining memory with agent logic, you move from stateless interactions to truly personalized, context-aware experiences.
Final Thoughts
Giving AI agents memory fundamentally changes how they interact with users. Instead of treating every conversation as a fresh start, agents can build long-term understanding and personalization over time. As AI agents become more capable, memory will play a key role in making them feel less like tools and more like intelligent collaborators. If you’re building agents in Foundry, Memory Store is definitely a feature worth exploring!
Happy coding, and have fun building smarter agents!🚀