Memory Store em Microsoft Foundry: Como Ensinar IA a Lembrar e o Impacto para Empresas Brasileiras
TL;DR: O Memory Store no Microsoft Foundry resolve o problema clássico de AI agents sem memória: manter contexto entre interações. Com memória estruturada (perfil de usuário + resumo de conversa), é possível criar assistentes que lembram preferências sem depender de engenharia de prompts complexa. O artigo traz um demo funcional em Python (com gpt-4.1 e embeddings) e mostra como empresas brasileiras podem usar isso para personalizar onboarding, recomendações e suporte ao cliente com baixa latência e isolamento por usuário.
Imagine interagir com um assistente de IA que lembra suas preferências — as ferramentas que você usa, os projetos em que está trabalhando ou até como gosta do seu café. Em muitos sistemas de IA hoje, manter esse tipo de memória de longo prazo não é trivial. Embora os modelos entendam contexto dentro de uma única conversa, lembrar informações importantes entre múltiplas interações exige infraestrutura adicional.
É exatamente esse problema que o Memory Store no Microsoft Foundry foi criado para resolver.
Neste artigo, vamos:
- Entender o que é Memory Store
- Ver por que ele é relevante para agentes do mundo real
- Construir um demo em Python
- Analisar as implicações práticas para times de engenharia no Brasil
O que é Memory Store no Microsoft Foundry?
Memory Store (em preview) no Foundry Agent Service é um sistema de memória de longo prazo gerenciado para seus AI agents.
Em termos simples: seu agente pode lembrar coisas entre conversas, sessões e até dispositivos. Não é apenas histórico de chat — é memória estruturada que pode armazenar:
- Preferências do usuário
- Fatos importantes
- Contexto resumido de conversas
O Memory Store permite continuidade e personalização do agente, mantendo as memórias seguras e isoladas por usuário.
Conceitos-chave
Memory Store
É o container onde as memórias vivem. Os memory stores atuam como armazenamento persistente, definindo quais tipos de informação são relevantes para cada agente.
Boa prática: crie um memory store por agente para manter limites de memória limpos e recuperação eficiente.
Escopo (Scope)
Define a quem a memória pertence. Pode ser um ID customizado (user_123) ou mapeado automaticamente usando {{$userId}} dos cabeçalhos de autenticação. Isso garante privacidade e isolamento por design — a memória pertence apenas àquele usuário.
Tipos de memória
User profile memory: captura informações estáveis e de longo prazo (preferências, hábitos, escolhas repetidas). Essas memórias são injetadas como contexto estático no início de cada conversa.
Chat summary memory: captura insights condensados de conversas.
Como a Memory Store muda o jogo para aplicações brasileiras?
Empresas que operam em setores como varejo, finanças e saúde no Brasil frequentemente precisam de assistentes que reconheçam o cliente ao longo do tempo — desde um chatbot de e-commerce que lembra o tamanho de roupa preferido até um assistente de suporte técnico que sabe quais equipamentos o usuário já reportou. Sem memória gerenciada, cada interação recomeça do zero, gerando retrabalho e experiência inconsistente.
O Memory Store resolve isso com uma camada de persistência que pode ser acoplada a qualquer agente no Foundry, sem exigir que a equipe de engenharia construa um banco de memória próprio. Para times que já usam Azure, a integração é direta via SDK Python ou pela interface do Foundry.
Mini Demo: Ensinando um Agente a Lembrar
Vamos criar:
- Um memory store
- Um agente com memória
- Uma conversa onde o agente aprende algo
- Uma nova conversa onde ele lembra
Pré-requisitos
- Assinatura Azure
- Um projeto Microsoft Foundry
- Modelos implantados: chat (gpt-4.1 ou similar) e
text-embedding-3-small - Python 3.8+
Configuração do ambiente
pip install azure-ai-projects azure-identity openai python-dotenv
Crie um arquivo .env com sua connection string:
FOUNDRY_PROJECT_ENDPOINT=your_connection_string_here
Código completo do agente de café
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...")
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...")
agents = project_client.agents.list_versions(agent_name="CoffeeAgent")
if agents:
agent = agents[0]
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 esperado
Verificação no portal Foundry
Você também pode testar diretamente no portal: navegue até seu CoffeeAgent, abra a seção Memory, confirme que "coffee_memory_store" está conectado, e use o chat para perguntar "What coffee do I prefer?" — o agente lembrará da sua preferência.
Pontos de implementação importantes
- Escopo consistente: use o mesmo escopo de usuário em todas as ferramentas de memória para associação correta de contexto.
- Gerenciamento de recursos: trate recursos existentes com elegância para código reutilizável (veja as cláusulas
try/exceptno demo). - Processamento de memória: aguarde tempo suficiente entre conversas para que a memória seja processada (65s no demo, mas pode ser ajustado).
- Instruções do agente: inclua capacidades de memória nas instruções do agente para melhor performance.
Opções de personalização
- Escopo: use diferentes IDs de usuário para aplicações multi-usuário.
- Instruções do agente: adapte personalidade e padrões de uso de memória.
- Update delay: ajuste o
update_delayno código conforme suas necessidades de performance.
Próximos passos e recursos
- What is Memory? – Microsoft Foundry | Microsoft Learn
- Create and Use Memory – Microsoft Foundry | Microsoft Learn
- Microsoft Foundry documentation
Ideias para estender o demo
- Armazenar múltiplas preferências (bebida, horário, localização)
- Usar escopos dinâmicos (
{{$userId}}) para aplicações multi-usuário - Observar como a memória evolui entre várias conversas e sessões
Casos de uso práticos para empresas brasileiras
- Assistente de onboarding personalizado que lembra preferências do usuário
- Motor de recomendação inteligente (alimentação, ferramentas, trilhas de aprendizado)
- Agente de suporte ao cliente com contexto de longo prazo e continuidade de conversa
Considerações finais
Dar memória a AI agents muda fundamentalmente como eles interagem com usuários. Em vez de tratar cada conversa como um recomeço, os agentes podem construir entendimento e personalização de longo prazo. Conforme os agentes se tornam mais capazes, a memória será um diferencial para torná-los menos uma ferramenta e mais um colaborador inteligente.
Para empresas brasileiras que dependem de Azure e buscam reduzir o atrito em experiências digitais, o Memory Store é uma peça importante para sair de interações stateless para experiências verdadeiramente personalizadas e contextuais.
Perguntas Frequentes
-
O Memory Store do Foundry é compatível com modelos open-source?
Atualmente o Memory Store usa modelos específicos como gpt-4.1 para sumarização e text-embedding-3-small para embeddings. A Microsoft pode expandir suporte no futuro, mas hoje a integração é com os próprios modelos do Azure OpenAI. -
Preciso de uma assinatura Azure para usar o Memory Store?
Sim. O Memory Store é parte do Foundry Agent Service dentro do ecossistema Azure. Você precisa de um projeto Foundry ativo, modelos de chat e embeddings implantados, e uma conta Azure com permissões adequadas. -
Como garantir privacidade dos dados dos usuários com Memory Store?
O sistema usa escopos (scope) por usuário. Pode-se usar um ID customizado ou o {{$userId}} do header de autenticação. Isso isola as memórias de cada usuário, garantindo que nenhuma informação vaze entre conversas ou clientes diferentes. -
Qual é o delay típico para escrita de memória entre conversas?
O demo usa um sleep de 65 segundos para garantir que o debounce e a escrita da memória sejam concluídos. Em produção, o delay pode ser configurado via 'update_delay' e varia conforme a carga e o modelo de sumarização escolhido.
Artigo originalmente publicado em Azure Updates - Latest from Azure Charts.
