Memória

from crewai import Memory

memory = Memory()

# Armazenar -- o LLM infere escopo, categorias e importância
memory.remember("Decidimos usar PostgreSQL para o banco de dados de usuários.")

# Recuperar -- resultados ranqueados por pontuação composta (semântica + recência + importância)
matches = memory.recall("Qual banco de dados escolhemos?")
for m in matches:
    print(f"[{m.score:.2f}] {m.record.content}")

# Ajustar pontuação para um projeto dinâmico
memory = Memory(recency_weight=0.5, recency_half_life_days=7)

# Esquecer
memory.forget(scope="/project/old")

# Explorar a árvore de escopos auto-organizada
print(memory.tree())
print(memory.info("/"))

from crewai import Memory

memory = Memory()

# Construir conhecimento
memory.remember("O limite da API é 1000 requisições por minuto.")
memory.remember("Nosso ambiente de staging usa a porta 8080.")
memory.remember("A equipe concordou em usar feature flags para todos os novos lançamentos.")

# Depois, recupere o que precisar
matches = memory.recall("Quais são nossos limites de API?", limit=5)
for m in matches:
    print(f"[{m.score:.2f}] {m.record.content}")

# Extrair fatos atômicos de um texto mais longo
raw = """Notas da reunião: Decidimos migrar do MySQL para PostgreSQL
no próximo trimestre. O orçamento é de $50k. Sarah liderará a migração."""

facts = memory.extract_memories(raw)
# ["Migração de MySQL para PostgreSQL planejada para o próximo trimestre",
#  "Orçamento da migração de banco de dados é $50k",
#  "Sarah liderará a migração do banco de dados"]

for fact in facts:
    memory.remember(fact)

from crewai import Crew, Agent, Task, Process, Memory

# Opção 1: Memória padrão
crew = Crew(
    agents=[researcher, writer],
    tasks=[research_task, writing_task],
    process=Process.sequential,
    memory=True,
    verbose=True,
)

# Opção 2: Memória customizada com pontuação ajustada
memory = Memory(
    recency_weight=0.4,
    semantic_weight=0.4,
    importance_weight=0.2,
    recency_half_life_days=14,
)
crew = Crew(
    agents=[researcher, writer],
    tasks=[research_task, writing_task],
    memory=memory,
)

from crewai import Agent, Memory

memory = Memory()

# Pesquisador recebe um escopo privado -- só vê /agent/researcher
researcher = Agent(
    role="Researcher",
    goal="Encontrar e analisar informações",
    backstory="Pesquisador experiente com atenção aos detalhes",
    memory=memory.scope("/agent/researcher"),
)

# Escritor usa memória compartilhada da crew (sem memória própria)
writer = Agent(
    role="Writer",
    goal="Produzir conteúdo claro e bem estruturado",
    backstory="Escritor técnico experiente",
    # memory não definido -- usa crew._memory quando a crew tem memória habilitada
)

from crewai.flow.flow import Flow, listen, start

class ResearchFlow(Flow):
    @start()
    def gather_data(self):
        findings = "PostgreSQL suporta 10k conexões simultâneas. MySQL limita a 5k."
        self.remember(findings, scope="/research/databases")
        return findings

    @listen(gather_data)
    def write_report(self, findings):
        # Recuperar pesquisas anteriores para fornecer contexto
        past = self.recall("benchmarks de performance de banco de dados")
        context = "\n".join(f"- {m.record.content}" for m in past)
        return f"Relatório:\nNovas descobertas: {findings}\nContexto anterior:\n{context}"

/
  /company
    /company/engineering
    /company/product
  /project
    /project/alpha
    /project/beta
  /agent
    /agent/researcher
    /agent/writer

memory = Memory()

# LLM infere escopo a partir do conteúdo
memory.remember("Escolhemos PostgreSQL para o banco de dados de usuários.")
# -> pode ser colocado em /project/decisions ou /engineering/database

# Você também pode especificar o escopo explicitamente
memory.remember("Velocidade do sprint é 42 pontos", scope="/team/metrics")

print(memory.tree())
# / (15 records)
#   /project (8 records)
#     /project/alpha (5 records)
#     /project/beta (3 records)
#   /agent (7 records)
#     /agent/researcher (4 records)
#     /agent/writer (3 records)

print(memory.info("/project/alpha"))
# ScopeInfo(path='/project/alpha', record_count=5,
#           categories=['architecture', 'database'],
#           oldest_record=datetime(...), newest_record=datetime(...),
#           child_scopes=[])

memory = Memory()

# Criar um escopo para um agente específico
agent_memory = memory.scope("/agent/researcher")

# Tudo é relativo a /agent/researcher
agent_memory.remember("Encontrados três papers relevantes sobre memória de LLM.")
# -> armazenado em /agent/researcher

agent_memory.recall("papers relevantes")
# -> busca apenas em /agent/researcher

# Restringir ainda mais com subscope
project_memory = agent_memory.subscope("project-alpha")
# -> /agent/researcher/project-alpha

memory = Memory()
# Cada projeto recebe sua própria ramificação
memory.remember("Usando arquitetura de microsserviços", scope="/project/alpha/architecture")
memory.remember("API GraphQL para apps cliente", scope="/project/beta/api")

# Recall em todos os projetos
memory.recall("decisões de design de API")

# Ou dentro de um projeto específico
memory.recall("design de API", scope="/project/beta")

memory = Memory()

# Pesquisador tem descobertas privadas
researcher_memory = memory.scope("/agent/researcher")

# Escritor pode ler de seu próprio escopo e do conhecimento compartilhado da empresa
writer_view = memory.slice(
    scopes=["/agent/writer", "/company/knowledge"],
    read_only=True,
)

memory = Memory()

# Cada cliente recebe contexto isolado
memory.remember("Prefere comunicação por email", scope="/customer/acme-corp")
memory.remember("Plano enterprise, 50 licenças", scope="/customer/acme-corp")

# Docs de produto compartilhados são acessíveis a todos os agentes
memory.remember("Limite de taxa é 1000 req/min no plano enterprise", scope="/product/docs")

memory = Memory()

# Agente pode fazer recall de seu próprio escopo E do conhecimento da empresa,
# mas não pode escrever no conhecimento da empresa
agent_view = memory.slice(
    scopes=["/agent/researcher", "/company/knowledge"],
    read_only=True,
)

matches = agent_view.recall("políticas de segurança da empresa", limit=5)
# Busca em /agent/researcher e /company/knowledge, mescla e ranqueia resultados

agent_view.remember("nova descoberta")  # Levanta PermissionError (somente leitura)

view = memory.slice(scopes=["/team/alpha", "/team/beta"], read_only=False)

# Deve especificar escopo ao escrever
view.remember("Decisão entre equipes", scope="/team/alpha", categories=["decisions"])

composite = semantic_weight * similarity + recency_weight * decay + importance_weight * importance

# Retrospectiva de sprint: favorecer memórias recentes, meia-vida curta
memory = Memory(
    recency_weight=0.5,
    semantic_weight=0.3,
    importance_weight=0.2,
    recency_half_life_days=7,
)

# Base de conhecimento de arquitetura: favorecer memórias importantes, meia-vida longa
memory = Memory(
    recency_weight=0.1,
    semantic_weight=0.5,
    importance_weight=0.4,
    recency_half_life_days=180,
)

# Apenas 2 registros são armazenados (o terceiro é quase duplicata do primeiro)
memory.remember_many([
    "CrewAI supports complex workflows.",
    "Python is a great language.",
    "CrewAI supports complex workflows.",  # descartado pelo dedup intra-batch
])

# Retorna imediatamente -- save acontece em background
memory.remember_many(["Fato A.", "Fato B.", "Fato C."])

# recall() espera automaticamente saves pendentes antes de buscar
matches = memory.recall("fatos")  # vê todos os 3 registros

memory = Memory()
memory.remember_many(["Fato A.", "Fato B."])

# Opção 1: Esperar saves pendentes
memory.drain_writes()

# Opção 2: Drenar e encerrar o pool de background
memory.close()

# Marcar memórias com sua origem
memory.remember("Usuário prefere modo escuro", source="user:alice")
memory.remember("Configuração do sistema atualizada", source="admin")
memory.remember("Agente encontrou um bug", source="agent:debugger")

# Recuperar apenas memórias de uma origem específica
matches = memory.recall("preferências do usuário", source="user:alice")

# Armazenar uma memória privada
memory.remember("A chave de API da Alice é sk-...", source="user:alice", private=True)

# Este recall vê a memória privada (source corresponde)
matches = memory.recall("chave de API", source="user:alice")

# Este recall NÃO a vê (source diferente)
matches = memory.recall("chave de API", source="user:bob")

# Acesso admin: ver todos os registros privados independente do source
matches = memory.recall("chave de API", include_private=True)

# Shallow: busca vetorial pura, sem LLM
matches = memory.recall("O que decidimos?", limit=10, depth="shallow")

# Deep (padrão): recuperação inteligente com análise LLM para consultas longas
matches = memory.recall(
    "Resuma todas as decisões de arquitetura deste trimestre",
    limit=10,
    depth="deep",
)

memory = Memory(
    confidence_threshold_high=0.9,   # Só sintetizar quando muito confiante
    confidence_threshold_low=0.4,    # Explorar mais profundamente de forma mais agressiva
    exploration_budget=2,            # Permitir até 2 rodadas de exploração
    query_analysis_threshold=200,    # Pular LLM para consultas menores que isso
)

from crewai import Memory

# Como um dict de configuração
memory = Memory(embedder={"provider": "openai", "config": {"model_name": "text-embedding-3-small"}})

# Como um callable pré-construído
from crewai.rag.embeddings.factory import build_embedder
embedder = build_embedder({"provider": "ollama", "config": {"model_name": "mxbai-embed-large"}})
memory = Memory(embedder=embedder)

from crewai import Crew

crew = Crew(
    agents=[...],
    tasks=[...],
    memory=True,
    embedder={"provider": "openai", "config": {"model_name": "text-embedding-3-small"}},
)

from crewai import Memory, LLM

# Padrão: gpt-4o-mini
memory = Memory()

# Usar um modelo OpenAI diferente
memory = Memory(llm="gpt-4o")

# Usar Anthropic
memory = Memory(llm="anthropic/claude-3-haiku-20240307")

# Usar Ollama para análise totalmente local/privada
memory = Memory(llm="ollama/llama3.2")

# Usar Google Gemini
memory = Memory(llm="gemini/gemini-2.0-flash")

# Passar uma instância LLM pré-configurada com configurações customizadas
llm = LLM(model="gpt-4o", temperature=0)
memory = Memory(llm=llm)

memory = Memory(
    llm="ollama/llama3.2",
    embedder={"provider": "ollama", "config": {"model_name": "mxbai-embed-large"}},
)

memory.tree()                        # Árvore formatada de escopos e contagem de registros
memory.tree("/project", max_depth=2) # Visão de subárvore
memory.info("/project")              # ScopeInfo: record_count, categories, oldest/newest
memory.list_scopes("/")              # Escopos filhos imediatos
memory.list_categories()             # Nomes e contagens de categorias
memory.list_records(scope="/project/alpha", limit=20)  # Registros em um escopo, mais recentes primeiro

from crewai.events import BaseEventListener, MemoryQueryCompletedEvent

class MemoryMonitor(BaseEventListener):
    def setup_listeners(self, crewai_event_bus):
        @crewai_event_bus.on(MemoryQueryCompletedEvent)
        def on_done(source, event):
            if getattr(event, "source_type", None) == "unified_memory":
                print(f"Query '{event.query}' completou em {event.query_time_ms:.0f}ms")

crewai memory                              # Abre o navegador TUI
crewai memory --storage-path ./my_memory   # Apontar para um diretório específico

crew.reset_memories(command_type="memory")  # Reseta memória unificada
# Ou em uma instância Memory:
memory.reset()                    # Todos os escopos
memory.reset(scope="/project/old")  # Apenas essa subárvore