AutoGPT is the vision of accessible AI for everyone, to use and to build on. Our mission is to provide the tools, so that you can focus on what matters.
feat(backend): add Graphiti temporal knowledge graph memory for CoPilot (#12720)
Nicholas Tindlee68dadd2c976
diff --git a/autogpt_platform/backend/.env.default b/autogpt_platform/backend/.env.defaultindex 8ba3f758d9..c01da95a03 100644--- a/autogpt_platform/backend/.env.default+++ b/autogpt_platform/backend/.env.default@@ -58,6 +58,16 @@ V0_API_KEY=OPEN_ROUTER_API_KEY=NVIDIA_API_KEY=+# Graphiti Temporal Knowledge Graph Memory+# Rollout controlled by LaunchDarkly flag "graphiti-memory"+# LLM/embedder keys fall back to OPEN_ROUTER_API_KEY and OPENAI_API_KEY when empty.+GRAPHITI_FALKORDB_HOST=localhost+GRAPHITI_FALKORDB_PORT=6380+GRAPHITI_FALKORDB_PASSWORD=+GRAPHITI_LLM_MODEL=gpt-4.1-mini+GRAPHITI_EMBEDDER_MODEL=text-embedding-3-small+GRAPHITI_SEMAPHORE_LIMIT=5+# Langfuse Prompt Management# Used for managing the CoPilot system prompt externally# Get credentials from https://cloud.langfuse.com or your self-hosted instancediff --git a/autogpt_platform/backend/backend/copilot/baseline/service.py b/autogpt_platform/backend/backend/copilot/baseline/service.pyindex b9134a67b7..a8044d80b7 100644--- a/autogpt_platform/backend/backend/copilot/baseline/service.py+++ b/autogpt_platform/backend/backend/copilot/baseline/service.py@@ -27,6 +27,7 @@ from opentelemetry import trace as otel_tracefrom backend.copilot.config import CopilotModefrom backend.copilot.context import get_workspace_manager, set_execution_context+from backend.copilot.graphiti.config import is_enabled_for_userfrom backend.copilot.model import (ChatMessage,ChatSession,@@ -34,7 +35,7 @@ from backend.copilot.model import (maybe_append_user_message,upsert_chat_session,)-from backend.copilot.prompting import get_baseline_supplement+from backend.copilot.prompting import get_baseline_supplement, get_graphiti_supplementfrom backend.copilot.response_model import (StreamBaseResponse,StreamError,@@ -1001,8 +1002,19 @@ async def stream_chat_completion_baseline(message_id = str(uuid.uuid4())- # Append tool documentation and technical notes- system_prompt = base_system_prompt + get_baseline_supplement()+ # Append tool documentation, technical notes, and Graphiti memory instructions+ graphiti_enabled = await is_enabled_for_user(user_id)++ graphiti_supplement = get_graphiti_supplement() if graphiti_enabled else ""+ system_prompt = base_system_prompt + get_baseline_supplement() + graphiti_supplement++ # Warm context: pre-load relevant facts from Graphiti on first turn+ if graphiti_enabled and user_id and len(session.messages) <= 1:+ from backend.copilot.graphiti.context import fetch_warm_context++ warm_ctx = await fetch_warm_context(user_id, message or "")+ if warm_ctx:+ system_prompt += f"\n\n{warm_ctx}"# Compress context if approaching the model's token limitmessages_for_context = await _compress_session_messages(@@ -1272,6 +1284,16 @@ async def stream_chat_completion_baseline(except Exception as persist_err:logger.error("[Baseline] Failed to persist session: %s", persist_err)+ # --- Graphiti: ingest conversation turn for temporal memory ---+ if graphiti_enabled and user_id and message and is_user_message:+ from backend.copilot.graphiti.ingest import enqueue_conversation_turn++ _ingest_task = asyncio.create_task(+ enqueue_conversation_turn(user_id, session_id, message)+ )+ _background_tasks.add(_ingest_task)+ _ingest_task.add_done_callback(_background_tasks.discard)+# --- Upload transcript for next-turn continuity ---# Backfill partial assistant text that wasn't recorded by the# conversation updater (e.g. when the stream aborted mid-round).diff --git a/autogpt_platform/backend/backend/copilot/graphiti/AGENTS.md b/autogpt_platform/backend/backend/copilot/graphiti/AGENTS.mdnew file mode 100644index 0000000000..d49f0529dc--- /dev/null+++ b/autogpt_platform/backend/backend/copilot/graphiti/AGENTS.md@@ -0,0 +1,197 @@+# Graphiti Memory++This directory contains the Graphiti-backed memory integration for CoPilot.+This file is developer documentation only — it is NOT injected into LLM prompts.+Runtime prompt instructions live in `prompting.py:get_graphiti_supplement()`.++## Scope++- Keep Graphiti and FalkorDB-specific logic in this package.+- Prefer changes here over scattering Graphiti behavior across unrelated copilot modules.++## Debugging++- Use raw FalkorDB queries to inspect stored nodes, episodes, and `RELATES_TO` facts before changing retrieval behavior.+- Distinguish user-provided facts, assistant-generated findings, and provenance/meta entities when evaluating memory quality.++## Design Intent++- Preserve per-user isolation through `group_id`-scoped databases and clients.+- Be careful about memory pollution from assistant/tool phrasing; extraction quality matters as much as ingestion success.+- Keep warm-context and tool-driven recall resilient: failures should degrade gracefully rather than break chat execution.++## Query Cookbook++Run everything from `autogpt_platform/backend` and use `poetry run ...`.++Get the `group_id` for a user:++```bash+poetry run python - <<'PY'+from backend.copilot.graphiti.client import derive_group_id+print(derive_group_id("883cc9da-fe37-4863-839b-acba022bf3ef"))+PY+```++Inspect graph counts:++```bash+poetry run python - <<'PY'+import asyncio+from backend.copilot.graphiti.client import derive_group_id+from backend.copilot.graphiti.config import graphiti_config+from backend.copilot.graphiti.falkordb_driver import AutoGPTFalkorDriver++USER_ID = "883cc9da-fe37-4863-839b-acba022bf3ef"+GROUP_ID = derive_group_id(USER_ID)++QUERIES = {+ "entities": "MATCH (n:Entity) RETURN count(n) AS count",+ "episodes": "MATCH (n:Episodic) RETURN count(n) AS count",+ "communities": "MATCH (n:Community) RETURN count(n) AS count",+ "relates_to_edges": "MATCH ()-[e:RELATES_TO]->() RETURN count(e) AS count",+}++async def run():+ driver = AutoGPTFalkorDriver(+ host=graphiti_config.falkordb_host,+ port=graphiti_config.falkordb_port,+ password=graphiti_config.falkordb_password or None,+ database=GROUP_ID,+ )+ try:+ for name, query in QUERIES.items():+ records, _, _ = await driver.execute_query(query)+ print(name, records[0]["count"])+ finally:+ await driver.close()++asyncio.run(run())+PY+```++List entities or relation-name counts:++```bash+poetry run python - <<'PY'+import asyncio+from backend.copilot.graphiti.client import derive_group_id+from backend.copilot.graphiti.config import graphiti_config+from backend.copilot.graphiti.falkordb_driver import AutoGPTFalkorDriver++USER_ID = "883cc9da-fe37-4863-839b-acba022bf3ef"+GROUP_ID = derive_group_id(USER_ID)++async def run():+ driver = AutoGPTFalkorDriver(+ host=graphiti_config.falkordb_host,+ port=graphiti_config.falkordb_port,+ password=graphiti_config.falkordb_password or None,+ database=GROUP_ID,+ )+ try:+ records, _, _ = await driver.execute_query(+ "MATCH (n:Entity) RETURN n.name AS name, n.summary AS summary ORDER BY n.name"+ )+ print("## entities")+ for row in records:+ print(row)++ records, _, _ = await driver.execute_query(+ """+ MATCH ()-[e:RELATES_TO]->()+ RETURN e.name AS relation, count(e) AS count+ ORDER BY count DESC, relation+ """+ )+ print("\\n## relation_counts")+ for row in records:+ print(row)+ finally:+ await driver.close()++asyncio.run(run())+PY+```++Inspect facts around one node:++```bash+poetry run python - <<'PY'+import asyncio+from backend.copilot.graphiti.client import derive_group_id+from backend.copilot.graphiti.config import graphiti_config+from backend.copilot.graphiti.falkordb_driver import AutoGPTFalkorDriver++USER_ID = "883cc9da-fe37-4863-839b-acba022bf3ef"+GROUP_ID = derive_group_id(USER_ID)+TARGET = "sarah"++async def run():+ driver = AutoGPTFalkorDriver(+ host=graphiti_config.falkordb_host,+ port=graphiti_config.falkordb_port,+ password=graphiti_config.falkordb_password or None,+ database=GROUP_ID,+ )+ try:+ records, _, _ = await driver.execute_query(+ """+ MATCH (a)-[e:RELATES_TO]->(b)+ WHERE (exists(a.name) AND toLower(a.name) = $target)+ OR (exists(b.name) AND toLower(b.name) = $target)+ RETURN a.name AS source, e.name AS relation, e.fact AS fact, b.name AS target+ ORDER BY e.created_at+ """,+ target=TARGET,+ )+ for row in records:+ print(row)+ finally:+ await driver.close()++asyncio.run(run())+PY+```++Inspect all chat messages for a user:++```bash+poetry run python - <<'PY'+import asyncio+from prisma import Prisma++USER_ID = "883cc9da-fe37-4863-839b-acba022bf3ef"++async def run():+ db = Prisma()+ await db.connect()+ try:+ rows = await db.query_raw(+ '''+ select cm."sessionId" as session_id,+ cm.sequence,+ cm.role,+ left(cm.content, 260) as content,+ cm."createdAt" as created_at+ from "ChatMessage" cm+ join "ChatSession" cs on cs.id = cm."sessionId"+ where cs."userId" = $1+ order by cm."createdAt", cm.sequence+ ''',+ USER_ID,+ )+ for row in rows:+ print(row)+ finally:+ await db.disconnect()++asyncio.run(run())+PY+```++Notes:++- `RELATES_TO` edges hold semantic facts. Inspect `e.name` and `e.fact`.+- `MENTIONS` edges are provenance from episodes to extracted nodes.+- Prefer directed queries `->` when checking for duplicates; undirected matches double-count mirrored edges.diff --git a/autogpt_platform/backend/backend/copilot/graphiti/CLAUDE.md b/autogpt_platform/backend/backend/copilot/graphiti/CLAUDE.mdnew file mode 100644index 0000000000..43c994c2d3--- /dev/null+++ b/autogpt_platform/backend/backend/copilot/graphiti/CLAUDE.md@@ -0,0 +1 @@diff --git a/autogpt_platform/backend/backend/copilot/graphiti/__init__.py b/autogpt_platform/backend/backend/copilot/graphiti/__init__.pynew file mode 100644index 0000000000..9517b4d8d2--- /dev/null+++ b/autogpt_platform/backend/backend/copilot/graphiti/__init__.py@@ -0,0 +1 @@+"""Graphiti temporal knowledge graph memory for AutoPilot."""diff --git a/autogpt_platform/backend/backend/copilot/graphiti/_format.py b/autogpt_platform/backend/backend/copilot/graphiti/_format.pynew file mode 100644index 0000000000..fb4a93e393--- /dev/null+++ b/autogpt_platform/backend/backend/copilot/graphiti/_format.py@@ -0,0 +1,34 @@+"""Shared attribute-resolution helpers for Graphiti edge/episode objects.++graphiti-core edge and episode objects have varying attribute names across+versions. These helpers centralise the fallback chains so there's one place+to update when upstream changes an attribute name.+"""+++def extract_fact(edge) -> str:+ """Extract the human-readable fact from an edge object."""+ return getattr(edge, "fact", None) or getattr(edge, "name", "") or ""+++def extract_temporal_validity(edge) -> tuple[str, str]:+ """Return ``(valid_from, valid_to)`` for an edge."""+ valid_from = getattr(edge, "valid_at", None) or "unknown"+ valid_to = getattr(edge, "invalid_at", None) or "present"+ return str(valid_from), str(valid_to)+++def extract_episode_body(episode, max_len: int = 500) -> str:+ """Extract the body text from an episode object, truncated to *max_len*."""+ body = str(+ getattr(episode, "content", None)+ or getattr(episode, "body", None)+ or getattr(episode, "episode_body", None)+ or ""+ )+ return body[:max_len]+++def extract_episode_timestamp(episode) -> str:+ """Extract the created_at timestamp from an episode object."""+ return str(getattr(episode, "created_at", None) or "")diff --git a/autogpt_platform/backend/backend/copilot/graphiti/_format_test.py b/autogpt_platform/backend/backend/copilot/graphiti/_format_test.pynew file mode 100644index 0000000000..836ef14bbc--- /dev/null+++ b/autogpt_platform/backend/backend/copilot/graphiti/_format_test.py@@ -0,0 +1,90 @@+"""Tests for shared attribute-resolution helpers."""++from types import SimpleNamespace++from backend.copilot.graphiti._format import (+ extract_episode_body,+ extract_episode_timestamp,+ extract_fact,+ extract_temporal_validity,+)+++def test_extract_fact_prefers_fact_attribute() -> None:+ edge = SimpleNamespace(fact="user likes python", name="preference")+ assert extract_fact(edge) == "user likes python"+++def test_extract_fact_falls_back_to_name() -> None:+ edge = SimpleNamespace(name="preference")+ assert extract_fact(edge) == "preference"+++def test_extract_fact_handles_none_fact() -> None:+ edge = SimpleNamespace(fact=None, name="fallback")+ assert extract_fact(edge) == "fallback"+++def test_extract_fact_handles_missing_both() -> None:+ edge = SimpleNamespace()+ assert extract_fact(edge) == ""+++def test_extract_temporal_validity_with_values() -> None:+ edge = SimpleNamespace(valid_at="2025-01-01", invalid_at="2025-12-31")+ assert extract_temporal_validity(edge) == ("2025-01-01", "2025-12-31")+++def test_extract_temporal_validity_defaults() -> None:+ edge = SimpleNamespace()+ assert extract_temporal_validity(edge) == ("unknown", "present")+++def test_extract_temporal_validity_none_values() -> None:+ edge = SimpleNamespace(valid_at=None, invalid_at=None)+ assert extract_temporal_validity(edge) == ("unknown", "present")+++def test_extract_episode_body_prefers_content() -> None:+ ep = SimpleNamespace(content="hello world", body="alt", episode_body="alt2")+ assert extract_episode_body(ep) == "hello world"+++def test_extract_episode_body_falls_back_to_body() -> None:+ ep = SimpleNamespace(body="fallback body")+ assert extract_episode_body(ep) == "fallback body"+++def test_extract_episode_body_falls_back_to_episode_body() -> None:+ ep = SimpleNamespace(episode_body="last resort")+ assert extract_episode_body(ep) == "last resort"+++def test_extract_episode_body_handles_none_all() -> None:+ ep = SimpleNamespace(content=None, body=None, episode_body=None)+ assert extract_episode_body(ep) == ""+++def test_extract_episode_body_truncates() -> None:+ ep = SimpleNamespace(content="x" * 1000)+ assert len(extract_episode_body(ep)) == 500+++def test_extract_episode_body_custom_max_len() -> None:+ ep = SimpleNamespace(content="x" * 100)+ assert len(extract_episode_body(ep, max_len=10)) == 10+++def test_extract_episode_timestamp_with_value() -> None:+ ep = SimpleNamespace(created_at="2025-01-01T00:00:00Z")+ assert extract_episode_timestamp(ep) == "2025-01-01T00:00:00Z"+++def test_extract_episode_timestamp_missing() -> None:+ ep = SimpleNamespace()+ assert extract_episode_timestamp(ep) == ""+++def test_extract_episode_timestamp_none() -> None:+ ep = SimpleNamespace(created_at=None)+ assert extract_episode_timestamp(ep) == ""diff --git a/autogpt_platform/backend/backend/copilot/graphiti/client.py b/autogpt_platform/backend/backend/copilot/graphiti/client.pynew file mode 100644index 0000000000..9710354915--- /dev/null+++ b/autogpt_platform/backend/backend/copilot/graphiti/client.py@@ -0,0 +1,168 @@+"""Graphiti client management with per-group_id isolation and LRU caching."""++import asyncio+import logging+import re++from cachetools import TTLCache++from .config import graphiti_config++logger = logging.getLogger(__name__)++_GROUP_ID_PATTERN = re.compile(r"^[a-zA-Z0-9_-]+$")+_MAX_GROUP_ID_LEN = 128++_client_cache: TTLCache | None = None+_cache_lock = asyncio.Lock()+++def derive_group_id(user_id: str) -> str:+ """Derive a deterministic, injection-safe group_id from a user_id.++ Strips to ``[a-zA-Z0-9_-]``, enforces max length, and prefixes with+ ``user_``. Raises if sanitization changed the input.+ """+ if not user_id:+ raise ValueError("user_id must be non-empty to derive group_id")++ safe_id = re.sub(r"[^a-zA-Z0-9_-]", "", user_id)[:_MAX_GROUP_ID_LEN]+ if not safe_id:+ raise ValueError(+ f"user_id '{user_id[:32]}...' yields empty group_id after sanitization"+ )++ if safe_id != user_id:+ raise ValueError(+ f"user_id contains invalid characters for group_id derivation "+ f"(original length={len(user_id)}, sanitized='{safe_id[:32]}'). "+ f"Only [a-zA-Z0-9_-] are allowed."+ )++ group_id = f"user_{safe_id}"+ if not _GROUP_ID_PATTERN.match(group_id):+ raise ValueError(f"Generated group_id '{group_id}' fails validation")++ return group_id+++def _close_client_driver(client) -> None:+ """Best-effort close of a Graphiti client's graph driver.++ Called on cache eviction (TTL expiry or manual pop) to prevent+ leaked FalkorDB connections. Runs the async ``driver.close()``+ in a fire-and-forget task if an event loop is running, otherwise+ logs and moves on.+ """+ driver = getattr(client, "graph_driver", None) or getattr(client, "driver", None)+ if driver is None or not hasattr(driver, "close"):+ return++ try:+ loop = asyncio.get_running_loop()+ loop.create_task(driver.close())+ except RuntimeError:+ logger.debug("No running event loop — skipping driver.close() on eviction")+++class _EvictingTTLCache(TTLCache):+ """TTLCache that closes Graphiti drivers on TTL expiry and capacity eviction.++ Overrides ``expire()`` (not ``__delitem__``) per cachetools maintainer+ guidance — ``expire()`` is the only hook that fires for TTL-expired items+ since the internal expiry path uses ``Cache.__delitem__`` directly,+ bypassing subclass overrides. ``popitem()`` handles capacity eviction.+ See https://github.com/tkem/cachetools/issues/205.+ """++ def expire(self, time=None):+ expired = super().expire(time)+ for _key, client in expired:+ _close_client_driver(client)+ return expired++ def popitem(self):+ key, client = super().popitem()+ _close_client_driver(client)+ return key, client+++def _get_cache() -> TTLCache:+ global _client_cache+ if _client_cache is None:+ _client_cache = _EvictingTTLCache(+ maxsize=graphiti_config.client_cache_maxsize,+ ttl=graphiti_config.client_cache_ttl,+ )+ return _client_cache+++async def get_graphiti_client(group_id: str):+ """Return a Graphiti client scoped to the given group_id.++ Each group_id gets its own ``Graphiti`` instance to prevent the+ ``self.driver`` mutation race condition when different groups are+ accessed concurrently. Instances are cached with a TTL to bound+ memory usage.++ Returns a ``graphiti_core.Graphiti`` instance.+ """+ from graphiti_core import Graphiti+ from graphiti_core.embedder import OpenAIEmbedder, OpenAIEmbedderConfig+ from graphiti_core.llm_client import LLMConfig, OpenAIClient++ from .falkordb_driver import AutoGPTFalkorDriver++ cache = _get_cache()++ async with _cache_lock:+ if group_id in cache:+ return cache[group_id]++ llm_config = LLMConfig(+ api_key=graphiti_config.resolve_llm_api_key(),+ model=graphiti_config.llm_model,+ small_model=graphiti_config.llm_model, # avoid gpt-4.1-nano dedup hallucination (#760)+ base_url=graphiti_config.resolve_llm_base_url(),+ )+ llm_client = OpenAIClient(config=llm_config)++ embedder_config = OpenAIEmbedderConfig(+ api_key=graphiti_config.resolve_embedder_api_key(),+ embedding_model=graphiti_config.embedder_model,+ base_url=graphiti_config.resolve_embedder_base_url(),+ )+ embedder = OpenAIEmbedder(config=embedder_config)++ graph_driver = AutoGPTFalkorDriver(+ host=graphiti_config.falkordb_host,+ port=graphiti_config.falkordb_port,+ password=graphiti_config.falkordb_password or None,+ database=group_id,+ )+ client = Graphiti(+ llm_client=llm_client,+ embedder=embedder,+ graph_driver=graph_driver,+ max_coroutines=graphiti_config.semaphore_limit,+ )++ cache[group_id] = client+ return client+++async def evict_client(group_id: str) -> None:+ """Remove a cached client and close its driver connection."""+ cache = _get_cache()+ # pop() may return None for expired or missing keys.+ # _EvictingTTLCache.expire() handles TTL-expired cleanup separately.+ client = cache.pop(group_id, None)+ if client is not None:+ driver = getattr(client, "graph_driver", None) or getattr(+ client, "driver", None+ )+ if driver and hasattr(driver, "close"):+ try:+ await driver.close()+ except Exception:+ logger.debug("Failed to close driver for %s", group_id, exc_info=True)diff --git a/autogpt_platform/backend/backend/copilot/graphiti/client_test.py b/autogpt_platform/backend/backend/copilot/graphiti/client_test.pynew file mode 100644index 0000000000..cd7ec17600--- /dev/null+++ b/autogpt_platform/backend/backend/copilot/graphiti/client_test.py@@ -0,0 +1,38 @@+"""Tests for Graphiti client management — derive_group_id and evict_client."""++import pytest++from .client import derive_group_id, evict_client+++class TestDeriveGroupId:+ def test_empty_user_id_raises(self) -> None:+ with pytest.raises(ValueError, match="non-empty"):+ derive_group_id("")++ def test_all_invalid_chars_raises(self) -> None:+ with pytest.raises(ValueError, match="empty group_id after sanitization"):+ derive_group_id("!!!")++ def test_user_id_with_stripped_chars_raises(self) -> None:+ with pytest.raises(ValueError, match="invalid characters"):+ derive_group_id("abc.def")++ def test_valid_uuid_passthrough(self) -> None:+ uid = "883cc9da-fe37-4863-839b-acba022bf3ef"+ result = derive_group_id(uid)+ assert result == f"user_{uid}"++ def test_simple_alphanumeric_id(self) -> None:+ result = derive_group_id("user123")+ assert result == "user_user123"++ def test_hyphens_and_underscores_allowed(self) -> None:+ result = derive_group_id("a-b_c")+ assert result == "user_a-b_c"+++class TestEvictClient:+ @pytest.mark.asyncio+ async def test_evict_nonexistent_group_id_does_not_raise(self) -> None:+ await evict_client("no-such-group-id")diff --git a/autogpt_platform/backend/backend/copilot/graphiti/config.py b/autogpt_platform/backend/backend/copilot/graphiti/config.pynew file mode 100644index 0000000000..94a452165a--- /dev/null+++ b/autogpt_platform/backend/backend/copilot/graphiti/config.py@@ -0,0 +1,153 @@+"""Configuration for Graphiti temporal knowledge graph integration."""++import os+from pathlib import Path++from pydantic import Field+from pydantic_settings import (+ BaseSettings,+ DotEnvSettingsSource,+ PydanticBaseSettingsSource,+ SettingsConfigDict,+)++from backend.util.clients import OPENROUTER_BASE_URL++_BACKEND_ROOT = Path(__file__).resolve().parents[3]+++class GraphitiConfig(BaseSettings):+ """Configuration for Graphiti memory integration.++ All fields use the ``GRAPHITI_`` env-var prefix, e.g. ``GRAPHITI_ENABLED``.+ LLM/embedder keys fall back to the platform-wide OpenRouter and OpenAI keys+ when left empty so that operators don't need to manage separate credentials.+ """++ model_config = SettingsConfigDict(env_prefix="GRAPHITI_", extra="allow")++ # FalkorDB connection+ falkordb_host: str = Field(default="localhost")+ falkordb_port: int = Field(default=6380)+ falkordb_password: str = Field(default="")++ # LLM for entity extraction (used by graphiti-core during ingestion)+ llm_model: str = Field(+ default="gpt-4.1-mini",+ description="Model for entity extraction — must support structured output",+ )+ llm_base_url: str = Field(+ default="",+ description="Base URL for LLM API — empty falls back to OPENROUTER_BASE_URL",+ )+ llm_api_key: str = Field(+ default="",+ description="API key for LLM — empty falls back to OPEN_ROUTER_API_KEY",+ )++ # Embedder (separate from LLM — embeddings go direct to OpenAI)+ embedder_model: str = Field(default="text-embedding-3-small")+ embedder_base_url: str = Field(+ default="",+ description="Base URL for embedder — empty uses OpenAI direct",+ )+ embedder_api_key: str = Field(+ default="",+ description="API key for embedder — empty falls back to OPENAI_API_KEY",+ )++ # Concurrency+ semaphore_limit: int = Field(+ default=5,+ description="Max concurrent LLM calls during ingestion (prevents rate limits)",+ )++ # Warm context+ context_max_facts: int = Field(default=20)+ context_timeout: float = Field(+ default=8.0,+ description="Seconds before warm context fetch is abandoned (needs headroom for FalkorDB cold connections)",+ )++ # Client cache+ client_cache_maxsize: int = Field(default=500)+ client_cache_ttl: int = Field(+ default=1800,+ description="TTL in seconds for cached Graphiti client instances (30 min)",+ )++ @classmethod+ def settings_customise_sources(+ cls,+ settings_cls: type[BaseSettings],+ init_settings: PydanticBaseSettingsSource,+ env_settings: PydanticBaseSettingsSource,+ dotenv_settings: PydanticBaseSettingsSource,+ file_secret_settings: PydanticBaseSettingsSource,+ ) -> tuple[PydanticBaseSettingsSource, ...]:+ return (+ init_settings,+ env_settings,+ file_secret_settings,+ DotEnvSettingsSource(settings_cls, env_file=_BACKEND_ROOT / ".env"),+ DotEnvSettingsSource(settings_cls, env_file=_BACKEND_ROOT / ".env.default"),+ )++ def resolve_llm_api_key(self) -> str:+ if self.llm_api_key:+ return self.llm_api_key+ return os.getenv("OPEN_ROUTER_API_KEY", "")++ def resolve_llm_base_url(self) -> str:+ if self.llm_base_url:+ return self.llm_base_url+ return OPENROUTER_BASE_URL++ def resolve_embedder_api_key(self) -> str:+ if self.embedder_api_key:+ return self.embedder_api_key+ return os.getenv("OPENAI_API_KEY", "")++ def resolve_embedder_base_url(self) -> str | None:+ if self.embedder_base_url:+ return self.embedder_base_url+ return None # OpenAI SDK default+++_graphiti_config: GraphitiConfig | None = None+++def _get_config() -> GraphitiConfig:+ global _graphiti_config+ if _graphiti_config is None:+ _graphiti_config = GraphitiConfig()+ return _graphiti_config+++# Backwards-compatible module-level attribute access.+# All internal code should use ``_get_config()`` to avoid import-time+# construction, but this keeps existing ``graphiti_config.xxx`` usage working.+class _LazyConfigProxy:+ def __getattr__(self, name: str):+ return getattr(_get_config(), name)+++graphiti_config = _LazyConfigProxy() # type: ignore[assignment]+++async def is_enabled_for_user(user_id: str | None) -> bool:+ """Check if Graphiti memory is enabled for a specific user.++ Gated solely by LaunchDarkly flag ``graphiti-memory``+ (Flag.GRAPHITI_MEMORY). When LD is not configured, defaults to False.+ """+ if not user_id:+ return False++ from backend.util.feature_flag import Flag, is_feature_enabled++ return await is_feature_enabled(+ Flag.GRAPHITI_MEMORY,+ user_id,+ default=False,+ )diff --git a/autogpt_platform/backend/backend/copilot/graphiti/config_test.py b/autogpt_platform/backend/backend/copilot/graphiti/config_test.pynew file mode 100644index 0000000000..7c7a90d7bc--- /dev/null+++ b/autogpt_platform/backend/backend/copilot/graphiti/config_test.py@@ -0,0 +1,103 @@+from unittest.mock import AsyncMock, patch++import pytest++from .config import GraphitiConfig, is_enabled_for_user++_ENV_VARS_TO_CLEAR = (+ "GRAPHITI_FALKORDB_HOST",+ "GRAPHITI_FALKORDB_PORT",+ "GRAPHITI_FALKORDB_PASSWORD",+ "OPEN_ROUTER_API_KEY",+ "OPENAI_API_KEY",+)++[email protected](autouse=True)+def _clean_env(monkeypatch: pytest.MonkeyPatch) -> None:+ for var in _ENV_VARS_TO_CLEAR:+ monkeypatch.delenv(var, raising=False)+++def test_graphiti_config_reads_backend_env_defaults() -> None:+ cfg = GraphitiConfig()++ assert cfg.falkordb_host == "localhost"+ assert cfg.falkordb_port == 6380+++class TestResolveLlmApiKey:+ def test_returns_configured_key_when_set(self) -> None:+ cfg = GraphitiConfig(llm_api_key="my-llm-key")+ assert cfg.resolve_llm_api_key() == "my-llm-key"++ def test_falls_back_to_open_router_env(+ self, monkeypatch: pytest.MonkeyPatch+ ) -> None:+ monkeypatch.setenv("OPEN_ROUTER_API_KEY", "fallback-router-key")+ cfg = GraphitiConfig(llm_api_key="")+ assert cfg.resolve_llm_api_key() == "fallback-router-key"++ def test_returns_empty_when_no_fallback(self) -> None:+ cfg = GraphitiConfig(llm_api_key="")+ assert cfg.resolve_llm_api_key() == ""+++class TestResolveLlmBaseUrl:+ def test_returns_configured_url_when_set(self) -> None:+ cfg = GraphitiConfig(llm_base_url="https://custom.api/v1")+ assert cfg.resolve_llm_base_url() == "https://custom.api/v1"++ def test_falls_back_to_openrouter_base_url(self) -> None:+ cfg = GraphitiConfig(llm_base_url="")+ result = cfg.resolve_llm_base_url()+ assert result == "https://openrouter.ai/api/v1"+++class TestResolveEmbedderApiKey:+ def test_returns_configured_key_when_set(self) -> None:+ cfg = GraphitiConfig(embedder_api_key="my-embedder-key")+ assert cfg.resolve_embedder_api_key() == "my-embedder-key"++ def test_falls_back_to_openai_api_key_env(+ self, monkeypatch: pytest.MonkeyPatch+ ) -> None:+ monkeypatch.setenv("OPENAI_API_KEY", "fallback-openai-key")+ cfg = GraphitiConfig(embedder_api_key="")+ assert cfg.resolve_embedder_api_key() == "fallback-openai-key"++ def test_returns_empty_when_no_fallback(self) -> None:+ cfg = GraphitiConfig(embedder_api_key="")+ assert cfg.resolve_embedder_api_key() == ""+++class TestResolveEmbedderBaseUrl:+ def test_returns_configured_url_when_set(self) -> None:+ cfg = GraphitiConfig(embedder_base_url="https://embed.custom/v1")+ assert cfg.resolve_embedder_base_url() == "https://embed.custom/v1"++ def test_returns_none_when_empty(self) -> None:+ cfg = GraphitiConfig(embedder_base_url="")+ assert cfg.resolve_embedder_base_url() is None+++class TestIsEnabledForUser:+ @pytest.mark.asyncio+ async def test_none_user_returns_false(self) -> None:+ result = await is_enabled_for_user(None)+ assert result is False++ @pytest.mark.asyncio+ async def test_empty_user_returns_false(self) -> None:+ result = await is_enabled_for_user("")+ assert result is False++ @pytest.mark.asyncio+ async def test_delegates_to_feature_flag(self) -> None:+ with patch(+ "backend.util.feature_flag.is_feature_enabled",+ new_callable=AsyncMock,+ return_value=True,+ ):+ result = await is_enabled_for_user("some-user-id")+ assert result is Truediff --git a/autogpt_platform/backend/backend/copilot/graphiti/context.py b/autogpt_platform/backend/backend/copilot/graphiti/context.pynew file mode 100644index 0000000000..46f9855ab7--- /dev/null+++ b/autogpt_platform/backend/backend/copilot/graphiti/context.py@@ -0,0 +1,93 @@+"""Warm context retrieval — pre-loads relevant facts at session start."""++import asyncio+import logging+from datetime import datetime, timezone++from ._format import (+ extract_episode_body,+ extract_episode_timestamp,+ extract_fact,+ extract_temporal_validity,+)+from .client import derive_group_id, get_graphiti_client+from .config import graphiti_config++logger = logging.getLogger(__name__)+++async def fetch_warm_context(user_id: str, message: str) -> str | None:+ """Fetch relevant temporal context for the current user and message.++ Called at the start of a session (first turn) to pre-load facts from+ prior conversations. Returns a formatted ``<temporal_context>`` block+ suitable for appending to the system prompt, or ``None`` on failure.++ Graceful degradation: any error (timeout, connection, graphiti-core bug)+ returns ``None`` so the copilot continues without temporal context.+ """+ if not user_id:+ return None++ try:+ return await asyncio.wait_for(+ _fetch(user_id, message),+ timeout=graphiti_config.context_timeout,+ )+ except asyncio.TimeoutError:+ logger.warning(+ "Graphiti warm context timed out after %.1fs",+ graphiti_config.context_timeout,+ )+ return None+ except Exception:+ logger.warning("Graphiti warm context fetch failed", exc_info=True)+ return None+++async def _fetch(user_id: str, message: str) -> str | None:+ group_id = derive_group_id(user_id)+ client = await get_graphiti_client(group_id)++ edges, episodes = await asyncio.gather(+ client.search(+ query=message,+ group_ids=[group_id],+ num_results=graphiti_config.context_max_facts,+ ),+ client.retrieve_episodes(+ reference_time=datetime.now(timezone.utc),+ group_ids=[group_id],+ last_n=5,+ ),+ )++ if not edges and not episodes:+ return None++ return _format_context(edges, episodes)+++def _format_context(edges, episodes) -> str:+ sections: list[str] = []++ if edges:+ fact_lines = []+ for e in edges:+ valid_from, valid_to = extract_temporal_validity(e)+ fact = extract_fact(e)+ fact_lines.append(f" - {fact} ({valid_from} — {valid_to})")+ sections.append("<FACTS>\n" + "\n".join(fact_lines) + "\n</FACTS>")++ if episodes:+ ep_lines = []+ for ep in episodes:+ ts = extract_episode_timestamp(ep)+ body = extract_episode_body(ep)+ ep_lines.append(f" - [{ts}] {body}")+ sections.append(+ "<RECENT_EPISODES>\n" + "\n".join(ep_lines) + "\n</RECENT_EPISODES>"+ )++ body = "\n\n".join(sections)+ return f"<temporal_context>\n{body}\n</temporal_context>"diff --git a/autogpt_platform/backend/backend/copilot/graphiti/context_test.py b/autogpt_platform/backend/backend/copilot/graphiti/context_test.pynew file mode 100644index 0000000000..616fefa218--- /dev/null+++ b/autogpt_platform/backend/backend/copilot/graphiti/context_test.py@@ -0,0 +1,54 @@+"""Tests for Graphiti warm context retrieval."""++import asyncio+from unittest.mock import AsyncMock, patch++import pytest++from . import context+from .context import fetch_warm_context+++class TestFetchWarmContextEmptyUserId:+ @pytest.mark.asyncio+ async def test_returns_none_for_empty_user_id(self) -> None:+ result = await fetch_warm_context("", "hello")+ assert result is None+++class TestFetchWarmContextTimeout:+ @pytest.mark.asyncio+ async def test_returns_none_on_timeout(+ self, monkeypatch: pytest.MonkeyPatch+ ) -> None:+ async def _slow_fetch(user_id: str, message: str) -> str:+ await asyncio.sleep(10)+ return "<temporal_context>data</temporal_context>"++ with patch.object(context, "_fetch", side_effect=_slow_fetch):+ # Set an extremely short timeout.+ monkeypatch.setattr(context.graphiti_config, "context_timeout", 0.01)+ result = await fetch_warm_context("valid-user-id", "hello")++ assert result is None+++class TestFetchWarmContextGeneralError:+ @pytest.mark.asyncio+ async def test_returns_none_on_unexpected_error(self) -> None:+ with (+ patch.object(+ context,+ "derive_group_id",+ return_value="user_abc",+ ),+ patch.object(+ context,+ "get_graphiti_client",+ new_callable=AsyncMock,+ side_effect=RuntimeError("connection lost"),+ ),+ ):+ result = await fetch_warm_context("abc", "hello")++ assert result is Nonediff --git a/autogpt_platform/backend/backend/copilot/graphiti/falkordb_driver.py b/autogpt_platform/backend/backend/copilot/graphiti/falkordb_driver.pynew file mode 100644index 0000000000..670f82a38b--- /dev/null+++ b/autogpt_platform/backend/backend/copilot/graphiti/falkordb_driver.py@@ -0,0 +1,34 @@+from graphiti_core.driver.falkordb import STOPWORDS+from graphiti_core.driver.falkordb_driver import FalkorDriver+from graphiti_core.helpers import validate_group_ids+++class AutoGPTFalkorDriver(FalkorDriver):+ def build_fulltext_query(+ self,+ query: str,+ group_ids: list[str] | None = None,+ max_query_length: int = 128,+ ) -> str:+ validate_group_ids(group_ids)++ group_filter = ""+ if group_ids:+ group_filter = f"(@group_id:{'|'.join(group_ids)})"++ sanitized_query = self.sanitize(query)+ query_words = sanitized_query.split()+ filtered_words = [word for word in query_words if word.lower() not in STOPWORDS]+ sanitized_query = " | ".join(filtered_words)++ if not sanitized_query:+ fulltext_query = group_filter+ elif not group_filter:+ fulltext_query = f"({sanitized_query})"+ else:+ fulltext_query = f"{group_filter} ({sanitized_query})"++ if len(fulltext_query) >= max_query_length:+ return ""++ return fulltext_querydiff --git a/autogpt_platform/backend/backend/copilot/graphiti/falkordb_driver_test.py b/autogpt_platform/backend/backend/copilot/graphiti/falkordb_driver_test.pynew file mode 100644index 0000000000..fc78765f16--- /dev/null+++ b/autogpt_platform/backend/backend/copilot/graphiti/falkordb_driver_test.py@@ -0,0 +1,43 @@+from .falkordb_driver import AutoGPTFalkorDriver+++def test_build_fulltext_query_uses_unquoted_group_ids_for_falkordb() -> None:+ driver = AutoGPTFalkorDriver()++ query = driver.build_fulltext_query(+ "Sarah",+ group_ids=["user_883cc9da-fe37-4863-839b-acba022bf3ef"],+ )++ assert query == "(@group_id:user_883cc9da-fe37-4863-839b-acba022bf3ef) (Sarah)"+ assert '"user_883cc9da-fe37-4863-839b-acba022bf3ef"' not in query+++def test_build_fulltext_query_joins_multiple_group_ids_with_or() -> None:+ driver = AutoGPTFalkorDriver()++ query = driver.build_fulltext_query("Sarah", group_ids=["user_a", "user_b"])++ assert query == "(@group_id:user_a|user_b) (Sarah)"+++def test_stopwords_only_query_returns_group_filter_only() -> None:+ """Line 25: sanitized_query is empty (all stopwords) but group_ids present."""+ driver = AutoGPTFalkorDriver()++ # "the" is a common stopword — the query should reduce to just the group filter.+ query = driver.build_fulltext_query(+ "the",+ group_ids=["user_abc"],+ )++ assert query == "(@group_id:user_abc)"+++def test_query_without_group_ids_returns_parenthesized_query() -> None:+ """Line 27: sanitized_query has content but no group_ids provided."""+ driver = AutoGPTFalkorDriver()++ query = driver.build_fulltext_query("Sarah", group_ids=None)++ assert query == "(Sarah)"diff --git a/autogpt_platform/backend/backend/copilot/graphiti/ingest.py b/autogpt_platform/backend/backend/copilot/graphiti/ingest.pynew file mode 100644index 0000000000..e36f521a35--- /dev/null+++ b/autogpt_platform/backend/backend/copilot/graphiti/ingest.py@@ -0,0 +1,197 @@+"""Async episode ingestion with per-user serialization.++graphiti-core requires sequential ``add_episode()`` calls within the same+group_id. This module provides a per-user asyncio.Queue that serializes+ingestion while keeping it fire-and-forget from the caller's perspective.+"""++import asyncio+import logging+from datetime import datetime, timezone++from graphiti_core.nodes import EpisodeType++from .client import derive_group_id, get_graphiti_client++logger = logging.getLogger(__name__)++_user_queues: dict[str, asyncio.Queue] = {}+_user_workers: dict[str, asyncio.Task] = {}+_workers_lock = asyncio.Lock()++# Idle workers are cleaned up after this many seconds of inactivity.+_WORKER_IDLE_TIMEOUT = 60++CUSTOM_EXTRACTION_INSTRUCTIONS = """+- Do not extract "User", "Assistant", "AI", "System", "CoPilot", or "human" as entity nodes.+- Do not extract software tool names, block names, API endpoint names, or internal system identifiers as entities.+- Do not extract action descriptions like "the assistant created..." as facts. Extract only the underlying user intent or real-world information.+- Focus on real-world entities: people, companies, products, projects, concepts, and preferences.+- Use canonical names: if the speaker says "my company" and context reveals it is "Acme Corp", use "Acme Corp".+"""+++async def _ingestion_worker(user_id: str, queue: asyncio.Queue) -> None:+ """Process episodes sequentially for a single user.++ Exits after ``_WORKER_IDLE_TIMEOUT`` seconds of inactivity so that+ idle workers don't leak memory indefinitely.+ """+ try:+ while True:+ try:+ payload = await asyncio.wait_for(+ queue.get(), timeout=_WORKER_IDLE_TIMEOUT+ )+ except asyncio.TimeoutError:+ break # idle — clean up below++ try:+ group_id = derive_group_id(user_id)+ client = await get_graphiti_client(group_id)+ await client.add_episode(**payload)+ except Exception:+ logger.warning(+ "Graphiti ingestion failed for user %s",+ user_id[:12],+ exc_info=True,+ )+ finally:+ queue.task_done()+ except asyncio.CancelledError:+ logger.debug("Ingestion worker cancelled for user %s", user_id[:12])+ raise+ finally:+ # Clean up so the next message re-creates the worker.+ _user_queues.pop(user_id, None)+ _user_workers.pop(user_id, None)+++async def enqueue_conversation_turn(+ user_id: str,+ session_id: str,+ user_msg: str,+) -> None:+ """Enqueue a conversation turn for async background ingestion.++ This returns almost immediately — the actual graphiti-core+ ``add_episode()`` call (which triggers LLM entity extraction)+ runs in a background worker task.+ """+ if not user_id:+ return++ try:+ group_id = derive_group_id(user_id)+ except ValueError:+ logger.warning("Invalid user_id for ingestion: %s", user_id[:12])+ return++ user_display_name = await _resolve_user_name(user_id)++ episode_name = f"conversation_{session_id}"++ # User's own words only, in graphiti's expected "Speaker: content" format.+ # Assistant response is excluded from extraction+ # (Zep Cloud approach: ignore_roles=["assistant"]).+ episode_body_for_graphiti = f"{user_display_name}: {user_msg}"++ source_description = f"User message in session {session_id}"++ queue = await _ensure_worker(user_id)++ try:+ queue.put_nowait(+ {+ "name": episode_name,+ "episode_body": episode_body_for_graphiti,+ "source": EpisodeType.message,+ "source_description": source_description,+ "reference_time": datetime.now(timezone.utc),+ "group_id": group_id,+ "custom_extraction_instructions": CUSTOM_EXTRACTION_INSTRUCTIONS,+ }+ )+ except asyncio.QueueFull:+ logger.warning(+ "Graphiti ingestion queue full for user %s — dropping episode",+ user_id[:12],+ )+++async def enqueue_episode(+ user_id: str,+ session_id: str,+ *,+ name: str,+ episode_body: str,+ source_description: str = "Conversation memory",+) -> bool:+ """Enqueue an arbitrary episode for background ingestion.++ Used by ``MemoryStoreTool`` so that explicit memory-store calls go+ through the same per-user serialization queue as conversation turns.++ Returns ``True`` if the episode was queued, ``False`` if it was dropped.+ """+ if not user_id:+ return False++ try:+ group_id = derive_group_id(user_id)+ except ValueError:+ logger.warning("Invalid user_id for episode ingestion: %s", user_id[:12])+ return False++ queue = await _ensure_worker(user_id)++ try:+ queue.put_nowait(+ {+ "name": name,+ "episode_body": episode_body,+ "source": EpisodeType.text,+ "source_description": source_description,+ "reference_time": datetime.now(timezone.utc),+ "group_id": group_id,+ "custom_extraction_instructions": CUSTOM_EXTRACTION_INSTRUCTIONS,+ }+ )+ return True+ except asyncio.QueueFull:+ logger.warning(+ "Graphiti ingestion queue full for user %s — dropping episode",+ user_id[:12],+ )+ return False+++async def _ensure_worker(user_id: str) -> asyncio.Queue:+ """Create a queue and worker for *user_id* if one doesn't exist.++ Returns the queue directly so callers don't need to look it up from+ ``_user_queues`` (which avoids a TOCTOU race if the worker times out+ and cleans up between this call and the put_nowait).+ """+ async with _workers_lock:+ if user_id not in _user_queues:+ q: asyncio.Queue = asyncio.Queue(maxsize=100)+ _user_queues[user_id] = q+ _user_workers[user_id] = asyncio.create_task(+ _ingestion_worker(user_id, q),+ name=f"graphiti-ingest-{user_id[:12]}",+ )+ return _user_queues[user_id]+++async def _resolve_user_name(user_id: str) -> str:+ """Get the user's display name from BusinessUnderstanding, or fall back to 'User'."""+ try:+ from backend.data.db_accessors import understanding_db++ understanding = await understanding_db().get_business_understanding(user_id)+ if understanding and understanding.user_name:+ return understanding.user_name+ except Exception:+ logger.debug("Could not resolve user name for %s", user_id[:12])+ return "User"diff --git a/autogpt_platform/backend/backend/copilot/graphiti/ingest_test.py b/autogpt_platform/backend/backend/copilot/graphiti/ingest_test.pynew file mode 100644index 0000000000..3aebd283a5--- /dev/null+++ b/autogpt_platform/backend/backend/copilot/graphiti/ingest_test.py@@ -0,0 +1,185 @@+"""Tests for Graphiti ingestion queue and worker logic."""++import asyncio+from types import SimpleNamespace+from unittest.mock import AsyncMock, MagicMock, patch++import pytest++from . import ingest+++def _clean_module_state() -> None:+ """Reset module-level state to avoid cross-test contamination."""+ ingest._user_queues.clear()+ ingest._user_workers.clear()++[email protected](autouse=True)+def _reset_state():+ _clean_module_state()+ yield+ # Cancel any lingering worker tasks.+ for task in ingest._user_workers.values():+ task.cancel()+ _clean_module_state()+++class TestIngestionWorkerExceptionHandling:+ @pytest.mark.asyncio+ async def test_worker_continues_after_client_error(self) -> None:+ """If get_graphiti_client raises, the worker logs and continues."""+ queue: asyncio.Queue = asyncio.Queue(maxsize=10)+ queue.put_nowait(+ {+ "name": "ep1",+ "episode_body": "hello",+ "source": "message",+ "source_description": "test",+ "reference_time": None,+ "group_id": "user_test",+ }+ )++ with (+ patch.object(+ ingest,+ "derive_group_id",+ return_value="user_test",+ ),+ patch.object(+ ingest,+ "get_graphiti_client",+ new_callable=AsyncMock,+ side_effect=RuntimeError("connection failed"),+ ),+ ):+ # Use a short idle timeout so the worker exits quickly.+ original_timeout = ingest._WORKER_IDLE_TIMEOUT+ ingest._WORKER_IDLE_TIMEOUT = 0.1+ try:+ await ingest._ingestion_worker("test-user", queue)+ finally:+ ingest._WORKER_IDLE_TIMEOUT = original_timeout++ # Worker processed the item (task_done called) and exited.+ assert queue.empty()+++class TestEnqueueConversationTurn:+ @pytest.mark.asyncio+ async def test_empty_user_id_returns_without_error(self) -> None:+ await ingest.enqueue_conversation_turn(+ user_id="",+ session_id="sess1",+ user_msg="hi",+ )+ # No queue should have been created.+ assert len(ingest._user_queues) == 0+++class TestQueueFullScenario:+ @pytest.mark.asyncio+ async def test_queue_full_logs_warning_no_crash(self) -> None:+ user_id = "abc-valid-id"++ mock_understanding = SimpleNamespace(user_name="Alice")+ mock_understanding_db = MagicMock()+ mock_understanding_db.return_value.get_business_understanding = AsyncMock(+ return_value=mock_understanding+ )++ with (+ patch.object(+ ingest,+ "derive_group_id",+ return_value="user_abc-valid-id",+ ),+ patch(+ "backend.copilot.graphiti.ingest._resolve_user_name",+ new_callable=AsyncMock,+ return_value="Alice",+ ),+ ):+ # Create a tiny queue so it fills instantly.+ await ingest._ensure_worker(user_id)+ # Replace the queue with one that is already full.+ tiny_q: asyncio.Queue = asyncio.Queue(maxsize=1)+ tiny_q.put_nowait({"dummy": True})+ ingest._user_queues[user_id] = tiny_q++ # Should not raise even though the queue is full.+ await ingest.enqueue_conversation_turn(+ user_id=user_id,+ session_id="sess1",+ user_msg="hi",+ )+++class TestResolveUserName:+ @pytest.mark.asyncio+ async def test_fallback_when_db_raises(self) -> None:+ mock_db = MagicMock()+ mock_db.return_value.get_business_understanding = AsyncMock(+ side_effect=RuntimeError("DB not available")+ )++ with patch(+ "backend.data.db_accessors.understanding_db",+ mock_db,+ ):+ name = await ingest._resolve_user_name("some-user-id")++ assert name == "User"++ @pytest.mark.asyncio+ async def test_returns_user_name_when_available(self) -> None:+ mock_understanding = SimpleNamespace(user_name="Alice")+ mock_db = MagicMock()+ mock_db.return_value.get_business_understanding = AsyncMock(+ return_value=mock_understanding+ )++ with patch(+ "backend.data.db_accessors.understanding_db",+ mock_db,+ ):+ name = await ingest._resolve_user_name("some-user-id")++ assert name == "Alice"++ @pytest.mark.asyncio+ async def test_returns_user_when_understanding_is_none(self) -> None:+ mock_db = MagicMock()+ mock_db.return_value.get_business_understanding = AsyncMock(return_value=None)++ with patch(+ "backend.data.db_accessors.understanding_db",+ mock_db,+ ):+ name = await ingest._resolve_user_name("some-user-id")++ assert name == "User"+++class TestWorkerIdleTimeout:+ @pytest.mark.asyncio+ async def test_worker_cleans_up_on_idle(self) -> None:+ user_id = "idle-user"+ queue: asyncio.Queue = asyncio.Queue(maxsize=10)++ # Pre-populate state so cleanup can remove entries.+ ingest._user_queues[user_id] = queue+ task_sentinel = MagicMock()+ ingest._user_workers[user_id] = task_sentinel++ original_timeout = ingest._WORKER_IDLE_TIMEOUT+ ingest._WORKER_IDLE_TIMEOUT = 0.05+ try:+ await ingest._ingestion_worker(user_id, queue)+ finally:+ ingest._WORKER_IDLE_TIMEOUT = original_timeout++ # After idle timeout the worker should have cleaned up.+ assert user_id not in ingest._user_queues+ assert user_id not in ingest._user_workersdiff --git a/autogpt_platform/backend/backend/copilot/permissions.py b/autogpt_platform/backend/backend/copilot/permissions.pyindex 99bb15ed2b..b201840cc9 100644--- a/autogpt_platform/backend/backend/copilot/permissions.py+++ b/autogpt_platform/backend/backend/copilot/permissions.py@@ -89,6 +89,8 @@ ToolName = Literal["get_mcp_guide","list_folders","list_workspace_files",+ "memory_search",+ "memory_store","move_agents_to_folder","move_folder","read_workspace_file",diff --git a/autogpt_platform/backend/backend/copilot/prompting.py b/autogpt_platform/backend/backend/copilot/prompting.pyindex dd630a2e9b..c620833345 100644--- a/autogpt_platform/backend/backend/copilot/prompting.py+++ b/autogpt_platform/backend/backend/copilot/prompting.py@@ -349,6 +349,42 @@ def get_sdk_supplement(use_e2b: bool, cwd: str = "") -> str:return _get_local_storage_supplement(cwd)+def get_graphiti_supplement() -> str:+ """Get the memory system instructions to append when Graphiti is enabled.++ Appended after the SDK/baseline supplement in both execution paths.+ """+ return """++## Memory System (Graphiti)+You have access to persistent temporal memory tools that remember facts across sessions.++### CRITICAL — ALWAYS SEARCH BEFORE ANSWERING:+**You MUST call memory_search before responding to ANY question that could involve information from a prior conversation.** This includes questions about people, processes, preferences, tools, contacts, rules, workflows, or any factual question. Do NOT say "I don't have that information" without searching first. If the user asks "who should I CC" or "what CRM do we use" — SEARCH FIRST, then answer from results.++### When to STORE (memory_store):+- User shares personal info, preferences, business context+- User describes workflows, tools they use, pain points+- Important decisions or outcomes from agent runs+- Relationships between people, organizations, events+- Operational rules (e.g. "invoices go out on the 1st", "CC Sarah on client stuff")+- When you learn something new about the user++### When to RECALL (memory_search):+- **BEFORE answering any factual or context-dependent question — ALWAYS**+- When the user references something from a past conversation+- When building an agent that should use past preferences+- At the START of every new conversation to check for relevant context++### MEMORY RULES:+- Facts have temporal validity — if something CHANGED (e.g., user switched from Shopify to WooCommerce), store the new fact. The system automatically invalidates the old one.+- Never fabricate memories. Only persist what the user actually said.+- Memory is private to this user — no other user can see it.+- group_id is handled automatically by the system — never set it yourself.+- When storing, be specific about operational rules and instructions (e.g., "CC Sarah on client communications" not just "Sarah is the assistant").+"""++def get_baseline_supplement() -> str:"""Get the supplement for baseline mode (direct OpenAI API).diff --git a/autogpt_platform/backend/backend/copilot/sdk/service.py b/autogpt_platform/backend/backend/copilot/sdk/service.pyindex d3e17f4892..c2a60a8ba0 100644--- a/autogpt_platform/backend/backend/copilot/sdk/service.py+++ b/autogpt_platform/backend/backend/copilot/sdk/service.py@@ -61,6 +61,7 @@ from ..constants import (is_transient_api_error,)from ..context import encode_cwd_for_cli+from ..graphiti.config import is_enabled_for_userfrom ..model import (ChatMessage,ChatSession,@@ -68,7 +69,7 @@ from ..model import (maybe_append_user_message,upsert_chat_session,)-from ..prompting import get_sdk_supplement+from ..prompting import get_graphiti_supplement, get_sdk_supplementfrom ..response_model import (StreamBaseResponse,StreamError,@@ -1979,6 +1980,7 @@ async def stream_chat_completion_sdk(turn_cache_read_tokens = 0turn_cache_creation_tokens = 0turn_cost_usd: float | None = None+ graphiti_enabled = False# Make sure there is no more code between the lock acquisition and try-block.try:@@ -2058,9 +2060,24 @@ async def stream_chat_completion_sdk(use_e2b = e2b_sandbox is not None# Append appropriate supplement (Claude gets tool schemas automatically)- system_prompt = base_system_prompt + get_sdk_supplement(- use_e2b=use_e2b, cwd=sdk_cwd++ graphiti_enabled = await is_enabled_for_user(user_id)++ graphiti_supplement = get_graphiti_supplement() if graphiti_enabled else ""+ system_prompt = (+ base_system_prompt+ + get_sdk_supplement(use_e2b=use_e2b, cwd=sdk_cwd)+ + graphiti_supplement)++ # Warm context: pre-load relevant facts from Graphiti on first turn+ if graphiti_enabled and user_id and len(session.messages) <= 1:+ from backend.copilot.graphiti.context import fetch_warm_context++ warm_ctx = await fetch_warm_context(user_id, message or "")+ if warm_ctx:+ system_prompt += f"\n\n{warm_ctx}"+# Process transcript download resulttranscript_msg_count = 0if dl:@@ -2782,6 +2799,16 @@ async def stream_chat_completion_sdk(_background_tasks.add(task)task.add_done_callback(_background_tasks.discard)+ # --- Graphiti: ingest conversation turn for temporal memory ---+ if graphiti_enabled and user_id and message and is_user_message:+ from backend.copilot.graphiti.ingest import enqueue_conversation_turn++ _ingest_task = asyncio.create_task(+ enqueue_conversation_turn(user_id, session_id, message)+ )+ _background_tasks.add(_ingest_task)+ _ingest_task.add_done_callback(_background_tasks.discard)+# --- Upload transcript for next-turn --resume ---# TranscriptBuilder is the single source of truth. It mirrors the# CLI's active context: on compaction, replace_entries() syncs itdiff --git a/autogpt_platform/backend/backend/copilot/tools/__init__.py b/autogpt_platform/backend/backend/copilot/tools/__init__.pyindex 6d1a054c32..c4913a9411 100644--- a/autogpt_platform/backend/backend/copilot/tools/__init__.py+++ b/autogpt_platform/backend/backend/copilot/tools/__init__.py@@ -26,6 +26,8 @@ from .fix_agent import FixAgentGraphToolfrom .get_agent_building_guide import GetAgentBuildingGuideToolfrom .get_doc_page import GetDocPageToolfrom .get_mcp_guide import GetMCPGuideTool+from .graphiti_search import MemorySearchTool+from .graphiti_store import MemoryStoreToolfrom .manage_folders import (CreateFolderTool,DeleteFolderTool,@@ -63,6 +65,9 @@ TOOL_REGISTRY: dict[str, BaseTool] = {"find_agent": FindAgentTool(),"find_block": FindBlockTool(),"find_library_agent": FindLibraryAgentTool(),+ # Graphiti memory tools+ "memory_search": MemorySearchTool(),+ "memory_store": MemoryStoreTool(),# Folder management tools"create_folder": CreateFolderTool(),"list_folders": ListFoldersTool(),diff --git a/autogpt_platform/backend/backend/copilot/tools/graphiti_search.py b/autogpt_platform/backend/backend/copilot/tools/graphiti_search.pynew file mode 100644index 0000000000..27f47a6b29--- /dev/null+++ b/autogpt_platform/backend/backend/copilot/tools/graphiti_search.py@@ -0,0 +1,162 @@+"""Tool for searching the Graphiti temporal knowledge graph."""++import asyncio+import logging+from datetime import datetime, timezone+from typing import Any++from backend.copilot.graphiti._format import (+ extract_episode_body,+ extract_episode_timestamp,+ extract_fact,+ extract_temporal_validity,+)+from backend.copilot.graphiti.client import derive_group_id, get_graphiti_client+from backend.copilot.graphiti.config import is_enabled_for_user+from backend.copilot.model import ChatSession++from .base import BaseTool+from .models import ErrorResponse, MemorySearchResponse, ToolResponseBase++logger = logging.getLogger(__name__)++_MAX_LIMIT = 50+++class MemorySearchTool(BaseTool):+ """Search the user's temporal knowledge graph for stored memories."""++ @property+ def name(self) -> str:+ return "memory_search"++ @property+ def description(self) -> str:+ return (+ "Search the user's memory graph for facts, preferences, and context "+ "from prior sessions. Use before answering context-dependent questions "+ "or when the user references something from a past conversation."+ )++ @property+ def parameters(self) -> dict[str, Any]:+ return {+ "type": "object",+ "properties": {+ "query": {+ "type": "string",+ "description": "Natural language search query",+ },+ "limit": {+ "type": "integer",+ "description": "Maximum number of results to return",+ "default": 15,+ },+ },+ "required": ["query"],+ }++ @property+ def requires_auth(self) -> bool:+ return True++ async def _execute(+ self,+ user_id: str | None,+ session: ChatSession,+ *,+ query: str = "",+ limit: int = 15,+ **kwargs,+ ) -> ToolResponseBase:+ if not user_id:+ return ErrorResponse(+ message="Authentication required to search memories.",+ session_id=session.session_id,+ )++ if not await is_enabled_for_user(user_id):+ return ErrorResponse(+ message="Memory features are not enabled for your account.",+ session_id=session.session_id,+ )++ if not query:+ return ErrorResponse(+ message="A search query is required.",+ session_id=session.session_id,+ )++ limit = min(limit, _MAX_LIMIT)++ try:+ group_id = derive_group_id(user_id)+ except ValueError:+ return ErrorResponse(+ message="Invalid user ID for memory operations.",+ session_id=session.session_id,+ )++ try:+ client = await get_graphiti_client(group_id)++ edges, episodes = await asyncio.gather(+ client.search(+ query=query,+ group_ids=[group_id],+ num_results=limit,+ ),+ client.retrieve_episodes(+ reference_time=datetime.now(timezone.utc),+ group_ids=[group_id],+ last_n=5,+ ),+ )+ except Exception:+ logger.warning(+ "Memory search failed for user %s", user_id[:12], exc_info=True+ )+ return ErrorResponse(+ message="Memory search is temporarily unavailable.",+ session_id=session.session_id,+ )++ facts = _format_edges(edges)+ recent = _format_episodes(episodes)++ if not facts and not recent:+ return MemorySearchResponse(+ message="No memories found matching your query.",+ session_id=session.session_id,+ facts=[],+ recent_episodes=[],+ )++ return MemorySearchResponse(+ message=(+ f"Found {len(facts)} relationship facts and {len(recent)} stored memories. "+ "Use BOTH sections to answer — stored memories often contain operational "+ "rules and instructions that relationship facts summarize."+ ),+ session_id=session.session_id,+ facts=facts,+ recent_episodes=recent,+ )+++def _format_edges(edges) -> list[str]:+ results = []+ for e in edges:+ fact = extract_fact(e)+ valid_from, valid_to = extract_temporal_validity(e)+ results.append(f"{fact} (valid: {valid_from} — {valid_to})")+ return results+++def _format_episodes(episodes) -> list[str]:+ results = []+ for ep in episodes:+ ts = extract_episode_timestamp(ep)+ body = extract_episode_body(ep)+ results.append(f"[{ts}] {body}")+ return resultsdiff --git a/autogpt_platform/backend/backend/copilot/tools/graphiti_store.py b/autogpt_platform/backend/backend/copilot/tools/graphiti_store.pynew file mode 100644index 0000000000..6e75eb2ed4--- /dev/null+++ b/autogpt_platform/backend/backend/copilot/tools/graphiti_store.py@@ -0,0 +1,104 @@+"""Tool for storing memories in the Graphiti temporal knowledge graph."""++import logging+from typing import Any++from backend.copilot.graphiti.config import is_enabled_for_user+from backend.copilot.graphiti.ingest import enqueue_episode+from backend.copilot.model import ChatSession++from .base import BaseTool+from .models import ErrorResponse, MemoryStoreResponse, ToolResponseBase++logger = logging.getLogger(__name__)+++class MemoryStoreTool(BaseTool):+ """Store a memory/fact in the user's temporal knowledge graph."""++ @property+ def name(self) -> str:+ return "memory_store"++ @property+ def description(self) -> str:+ return (+ "Store a memory or fact about the user for future recall. "+ "Use when the user shares preferences, business context, decisions, "+ "relationships, or other important information worth remembering "+ "across sessions."+ )++ @property+ def parameters(self) -> dict[str, Any]:+ return {+ "type": "object",+ "properties": {+ "name": {+ "type": "string",+ "description": "Brief descriptive name for this memory (e.g. 'user_prefers_python')",+ },+ "content": {+ "type": "string",+ "description": "The information to remember. Be concise but complete.",+ },+ "source_description": {+ "type": "string",+ "description": "Context about where this info came from",+ "default": "Conversation memory",+ },+ },+ "required": ["name", "content"],+ }++ @property+ def requires_auth(self) -> bool:+ return True++ async def _execute(+ self,+ user_id: str | None,+ session: ChatSession,+ *,+ name: str = "",+ content: str = "",+ source_description: str = "Conversation memory",+ **kwargs,+ ) -> ToolResponseBase:+ if not user_id:+ return ErrorResponse(+ message="Authentication required to store memories.",+ session_id=session.session_id,+ )++ if not await is_enabled_for_user(user_id):+ return ErrorResponse(+ message="Memory features are not enabled for your account.",+ session_id=session.session_id,+ )++ if not name or not content:+ return ErrorResponse(+ message="Both 'name' and 'content' are required.",+ session_id=session.session_id,+ )++ queued = await enqueue_episode(+ user_id,+ session.session_id,+ name=name,+ episode_body=content,+ source_description=source_description,+ )++ if not queued:+ return ErrorResponse(+ message="Memory queue is full — please try again shortly.",+ session_id=session.session_id,+ )++ return MemoryStoreResponse(+ message=f"Memory '{name}' queued for storage.",+ session_id=session.session_id,+ memory_name=name,+ )diff --git a/autogpt_platform/backend/backend/copilot/tools/graphiti_store_test.py b/autogpt_platform/backend/backend/copilot/tools/graphiti_store_test.pynew file mode 100644index 0000000000..3742355d76--- /dev/null+++ b/autogpt_platform/backend/backend/copilot/tools/graphiti_store_test.py@@ -0,0 +1,196 @@+"""Tests for MemoryStoreTool."""++from datetime import UTC, datetime+from unittest.mock import AsyncMock, patch++import pytest++from backend.copilot.model import ChatSession+from backend.copilot.tools.graphiti_store import MemoryStoreTool+from backend.copilot.tools.models import ErrorResponse, MemoryStoreResponse+++def _make_session(session_id: str = "test-session") -> ChatSession:+ return ChatSession(+ session_id=session_id,+ user_id="test-user",+ title=None,+ messages=[],+ usage=[],+ credentials={},+ started_at=datetime.now(UTC),+ updated_at=datetime.now(UTC),+ )+++class TestMemoryStoreTool:+ """Tests for MemoryStoreTool._execute."""++ @pytest.mark.asyncio+ async def test_store_no_user_returns_error(self):+ tool = MemoryStoreTool()+ session = _make_session()++ result = await tool._execute(+ user_id=None,+ session=session,+ name="pref",+ content="likes python",+ )++ assert isinstance(result, ErrorResponse)+ assert "Authentication required" in result.message+ assert result.session_id == "test-session"++ @pytest.mark.asyncio+ async def test_store_feature_disabled_returns_error(self):+ tool = MemoryStoreTool()+ session = _make_session()++ with patch(+ "backend.copilot.tools.graphiti_store.is_enabled_for_user",+ new_callable=AsyncMock,+ return_value=False,+ ):+ result = await tool._execute(+ user_id="user-1",+ session=session,+ name="pref",+ content="likes python",+ )++ assert isinstance(result, ErrorResponse)+ assert "not enabled" in result.message++ @pytest.mark.asyncio+ async def test_store_missing_name_returns_error(self):+ tool = MemoryStoreTool()+ session = _make_session()++ with patch(+ "backend.copilot.tools.graphiti_store.is_enabled_for_user",+ new_callable=AsyncMock,+ return_value=True,+ ):+ result = await tool._execute(+ user_id="user-1",+ session=session,+ name="",+ content="likes python",+ )++ assert isinstance(result, ErrorResponse)+ assert "'name' and 'content' are required" in result.message++ @pytest.mark.asyncio+ async def test_store_missing_content_returns_error(self):+ tool = MemoryStoreTool()+ session = _make_session()++ with patch(+ "backend.copilot.tools.graphiti_store.is_enabled_for_user",+ new_callable=AsyncMock,+ return_value=True,+ ):+ result = await tool._execute(+ user_id="user-1",+ session=session,+ name="pref",+ content="",+ )++ assert isinstance(result, ErrorResponse)+ assert "'name' and 'content' are required" in result.message++ @pytest.mark.asyncio+ async def test_store_missing_both_name_and_content_returns_error(self):+ tool = MemoryStoreTool()+ session = _make_session()++ with patch(+ "backend.copilot.tools.graphiti_store.is_enabled_for_user",+ new_callable=AsyncMock,+ return_value=True,+ ):+ result = await tool._execute(+ user_id="user-1",+ session=session,+ name="",+ content="",+ )++ assert isinstance(result, ErrorResponse)+ assert "'name' and 'content' are required" in result.message++ @pytest.mark.asyncio+ async def test_store_success_enqueues_episode(self):+ tool = MemoryStoreTool()+ session = _make_session()++ mock_enqueue = AsyncMock()++ with (+ patch(+ "backend.copilot.tools.graphiti_store.is_enabled_for_user",+ new_callable=AsyncMock,+ return_value=True,+ ),+ patch(+ "backend.copilot.tools.graphiti_store.enqueue_episode",+ mock_enqueue,+ ),+ ):+ result = await tool._execute(+ user_id="user-1",+ session=session,+ name="user_prefers_python",+ content="The user prefers Python over JavaScript.",+ source_description="Direct statement",+ )++ assert isinstance(result, MemoryStoreResponse)+ assert result.memory_name == "user_prefers_python"+ assert "queued for storage" in result.message+ assert result.session_id == "test-session"++ mock_enqueue.assert_awaited_once_with(+ "user-1",+ "test-session",+ name="user_prefers_python",+ episode_body="The user prefers Python over JavaScript.",+ source_description="Direct statement",+ )++ @pytest.mark.asyncio+ async def test_store_success_uses_default_source_description(self):+ tool = MemoryStoreTool()+ session = _make_session()++ mock_enqueue = AsyncMock()++ with (+ patch(+ "backend.copilot.tools.graphiti_store.is_enabled_for_user",+ new_callable=AsyncMock,+ return_value=True,+ ),+ patch(+ "backend.copilot.tools.graphiti_store.enqueue_episode",+ mock_enqueue,+ ),+ ):+ result = await tool._execute(+ user_id="user-1",+ session=session,+ name="some_fact",+ content="A fact worth remembering.",+ )++ assert isinstance(result, MemoryStoreResponse)+ mock_enqueue.assert_awaited_once_with(+ "user-1",+ "test-session",+ name="some_fact",+ episode_body="A fact worth remembering.",+ source_description="Conversation memory",+ )diff --git a/autogpt_platform/backend/backend/copilot/tools/models.py b/autogpt_platform/backend/backend/copilot/tools/models.pyindex a0d1ad13ef..6825688ec8 100644--- a/autogpt_platform/backend/backend/copilot/tools/models.py+++ b/autogpt_platform/backend/backend/copilot/tools/models.py@@ -81,6 +81,10 @@ class ResponseType(str, Enum):FEATURE_REQUEST_SEARCH = "feature_request_search"FEATURE_REQUEST_CREATED = "feature_request_created"+ # Graphiti memory+ MEMORY_STORE = "memory_store"+ MEMORY_SEARCH = "memory_search"+# Base response modelclass ToolResponseBase(BaseModel):@@ -688,3 +692,21 @@ class AgentsMovedToFolderResponse(ToolResponseBase):agent_names: list[str] = []folder_id: str | None = Nonecount: int = 0+++# --- Graphiti memory responses ---+++class MemoryStoreResponse(ToolResponseBase):+ """Response when a memory is stored."""++ type: ResponseType = ResponseType.MEMORY_STORE+ memory_name: str+++class MemorySearchResponse(ToolResponseBase):+ """Response when memories are searched."""++ type: ResponseType = ResponseType.MEMORY_SEARCH+ facts: list[str] = Field(default_factory=list)+ recent_episodes: list[str] = Field(default_factory=list)diff --git a/autogpt_platform/backend/backend/data/db_manager_test.py b/autogpt_platform/backend/backend/data/db_manager_test.pynew file mode 100644index 0000000000..fa290abb49--- /dev/null+++ b/autogpt_platform/backend/backend/data/db_manager_test.py@@ -0,0 +1,6 @@+from .db_manager import DatabaseManagerAsyncClient+++def test_async_client_exposes_chat_methods() -> None:+ assert hasattr(DatabaseManagerAsyncClient, "delete_chat_session")+ assert hasattr(DatabaseManagerAsyncClient, "set_turn_duration")diff --git a/autogpt_platform/backend/backend/util/feature_flag.py b/autogpt_platform/backend/backend/util/feature_flag.pyindex 47ad704fc3..74a0f960ed 100644--- a/autogpt_platform/backend/backend/util/feature_flag.py+++ b/autogpt_platform/backend/backend/util/feature_flag.py@@ -43,6 +43,7 @@ class Flag(str, Enum):COPILOT_SDK = "copilot-sdk"COPILOT_DAILY_TOKEN_LIMIT = "copilot-daily-token-limit"COPILOT_WEEKLY_TOKEN_LIMIT = "copilot-weekly-token-limit"+ GRAPHITI_MEMORY = "graphiti-memory"def is_configured() -> bool:diff --git a/autogpt_platform/backend/poetry.lock b/autogpt_platform/backend/poetry.lockindex ce0996417b..f82230d91f 100644--- a/autogpt_platform/backend/poetry.lock+++ b/autogpt_platform/backend/poetry.lock@@ -641,14 +641,14 @@ redis = ["redis (>=2.10.5)"][[package]]name = "cachetools"-version = "6.2.6"+version = "5.5.2"description = "Extensible memoizing collections and decorators"optional = false-python-versions = ">=3.9"+python-versions = ">=3.7"groups = ["main"]files = [- {file = "cachetools-6.2.6-py3-none-any.whl", hash = "sha256:8c9717235b3c651603fff0076db52d6acbfd1b338b8ed50256092f7ce9c85bda"},- {file = "cachetools-6.2.6.tar.gz", hash = "sha256:16c33e1f276b9a9c0b49ab5782d901e3ad3de0dd6da9bf9bcd29ac5672f2f9e6"},+ {file = "cachetools-5.5.2-py3-none-any.whl", hash = "sha256:d26a22bcc62eb95c3beabd9f1ee5e820d3d2704fe2967cbe350e20c8ffcd3f0a"},+ {file = "cachetools-5.5.2.tar.gz", hash = "sha256:1a661caa9175d26759571b2e19580f9d6393969e5dfca11fdb1f947a23e640d4"},][[package]]@@ -1551,6 +1551,22 @@ files = [[package.dependencies]tzdata = "*"+[[package]]+name = "falkordb"+version = "1.2.2"+description = "Python client for interacting with FalkorDB database"+optional = false+python-versions = "<4.0,>=3.8"+groups = ["main"]+files = [+ {file = "falkordb-1.2.2-py3-none-any.whl", hash = "sha256:cc1fcccaa1148be9e3d22d85af03d027f19b398e0f38d04424f3757a02744976"},+ {file = "falkordb-1.2.2.tar.gz", hash = "sha256:3fc150d3262b971916a0f2c15f419f7fe521a94fe3a672b6f174288d885fd239"},+]++[package.dependencies]+python-dateutil = ">=2.9.0,<3.0.0"+redis = ">=6.0.0,<7.0.0"+[[package]]name = "fastapi"version = "0.128.7"@@ -2305,6 +2321,41 @@ files = [[package.dependencies]requests = ">=2.20.0,<3.0"+[[package]]+name = "graphiti-core"+version = "0.28.2"+description = "A temporal graph building library"+optional = false+python-versions = "<4,>=3.10"+groups = ["main"]+files = [+ {file = "graphiti_core-0.28.2-py3-none-any.whl", hash = "sha256:4e1c19b7bc70a73a612a473144ed4b3fe615ac6d4c5d6b10f48e206a858bcb53"},+ {file = "graphiti_core-0.28.2.tar.gz", hash = "sha256:9b2a72f117827e015a21b610eb2c3acbe05310b79736abef7372e81247578e9d"},+]++[package.dependencies]+neo4j = ">=5.26.0"+numpy = ">=1.0.0"+openai = ">=1.91.0"+posthog = ">=3.0.0"+pydantic = ">=2.11.5"+python-dotenv = ">=1.0.1"+tenacity = ">=9.0.0"++[package.extras]+anthropic = ["anthropic (>=0.49.0)"]+dev = ["anthropic (>=0.49.0)", "boto3 (>=1.39.16)", "falkordb (>=1.1.2,<2.0.0)", "google-genai (>=1.8.0)", "groq (>=0.2.0)", "ipykernel (>=6.29.5)", "jupyterlab (>=4.2.4)", "kuzu (>=0.11.3)", "langchain-anthropic (>=0.2.4)", "langchain-aws (>=0.2.29)", "langchain-openai (>=0.2.6)", "langgraph (>=0.2.15)", "langsmith (>=0.1.108)", "opensearch-py (>=3.0.0)", "opentelemetry-sdk (>=1.20.0)", "pyright (>=1.1.404)", "pytest (>=8.3.3)", "pytest-asyncio (>=0.24.0)", "pytest-xdist (>=3.6.1)", "ruff (>=0.7.1)", "sentence-transformers (>=3.2.1)", "transformers (>=4.45.2)", "voyageai (>=0.2.3)"]+falkordb = ["falkordb (>=1.1.2,<2.0.0)"]+gliner2 = ["gliner2 (>=1.2.0) ; python_version >= \"3.11\""]+google-genai = ["google-genai (>=1.62.0)"]+groq = ["groq (>=0.2.0)"]+kuzu = ["kuzu (>=0.11.3)"]+neo4j-opensearch = ["boto3 (>=1.39.16)", "opensearch-py (>=3.0.0)"]+neptune = ["boto3 (>=1.39.16)", "langchain-aws (>=0.2.29)", "opensearch-py (>=3.0.0)"]+sentence-transformers = ["sentence-transformers (>=3.2.1)"]+tracing = ["opentelemetry-api (>=1.20.0)", "opentelemetry-sdk (>=1.20.0)"]+voyageai = ["voyageai (>=0.2.3)"]+[[package]]name = "gravitas-md2gdocs"version = "0.1.0"@@ -3893,6 +3944,26 @@ files = [{file = "mypy_extensions-1.1.0.tar.gz", hash = "sha256:52e68efc3284861e772bbcd66823fde5ae21fd2fdb51c62a211403730b916558"},]+[[package]]+name = "neo4j"+version = "6.1.0"+description = "Neo4j Bolt driver for Python"+optional = false+python-versions = ">=3.10"+groups = ["main"]+files = [+ {file = "neo4j-6.1.0-py3-none-any.whl", hash = "sha256:3bd93941f3a3559af197031157220af9fd71f4f93a311db687bd69ffa417b67d"},+ {file = "neo4j-6.1.0.tar.gz", hash = "sha256:b5dde8c0d8481e7b6ae3733569d990dd3e5befdc5d452f531ad1884ed3500b84"},+]++[package.dependencies]+pytz = "*"++[package.extras]+numpy = ["numpy (>=1.21.2,<3.0.0)"]+pandas = ["numpy (>=1.21.2,<3.0.0)", "pandas (>=1.1.0,<3.0.0)"]+pyarrow = ["pyarrow (>=6.0.0,<23.0.0)"]+[[package]]name = "nest-asyncio"version = "1.6.0"@@ -8857,4 +8928,4 @@ cffi = ["cffi (>=1.17,<2.0) ; platform_python_implementation != \"PyPy\" and pyt[metadata]lock-version = "2.1"python-versions = ">=3.10,<3.14"-content-hash = "8dd9db689a2dd57fc3cccea02e596a522f334f6b5ed18e92252555f61835d71d"+content-hash = "da61798b73758b9292fc1933268d488fbe739dc1fbf5c6586cd0c76a3411eb2e"diff --git a/autogpt_platform/backend/pyproject.toml b/autogpt_platform/backend/pyproject.tomlindex 4e16e3aa5c..ba82ecdd3c 100644--- a/autogpt_platform/backend/pyproject.toml+++ b/autogpt_platform/backend/pyproject.toml@@ -17,6 +17,7 @@ anthropic = "^0.79.0"apscheduler = "^3.11.1"autogpt-libs = { path = "../autogpt_libs", develop = true }bleach = { extras = ["css"], version = "^6.2.0" }+cachetools = "^5.5.0"claude-agent-sdk = "0.1.45" # see copilot/sdk/sdk_compat_test.py for capability checksclick = "^8.2.0"cryptography = "^46.0"@@ -24,6 +25,7 @@ discord-py = "^2.5.2"e2b = "^2.15.2"e2b-code-interpreter = "^2.0"elevenlabs = "^1.50.0"+falkordb = "^1.1.2"fastapi = "^0.128.6"feedparser = "^6.0.11"flake8 = "^7.3.0"@@ -32,6 +34,7 @@ google-auth-oauthlib = "^1.2.2"google-cloud-storage = "^3.2.0"googlemaps = "^4.10.0"gravitasml = "^0.1.4"+graphiti-core = "^0.28.2"groq = "^0.30.0"html2text = "^2024.2.26"jinja2 = "^3.1.6"@@ -168,4 +171,3 @@ filterwarnings = [[tool.ruff]target-version = "py310"-diff --git a/autogpt_platform/backend/schema.prisma b/autogpt_platform/backend/schema.prismaindex abe7e51d5d..ed71f620ba 100644--- a/autogpt_platform/backend/schema.prisma+++ b/autogpt_platform/backend/schema.prisma@@ -74,7 +74,6 @@ model User {NotificationBatches UserNotificationBatch[]PendingHumanReviews PendingHumanReview[]Workspace UserWorkspace?-PlatformCostLogs PlatformCostLog[]// OAuth Provider relations@@ -157,6 +156,7 @@ model CoPilotUnderstanding {@@index([userId])}+//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// USER WORKSPACE TABLES /////////////////diff --git a/autogpt_platform/docker-compose.platform.yml b/autogpt_platform/docker-compose.platform.ymlindex ee633531e1..29ab586a47 100644--- a/autogpt_platform/docker-compose.platform.yml+++ b/autogpt_platform/docker-compose.platform.yml@@ -17,6 +17,8 @@ x-backend-env: &backend-env # Docker internal service hostnames (override localhDB_HOST: dbREDIS_HOST: redisRABBITMQ_HOST: rabbitmq+ GRAPHITI_FALKORDB_HOST: falkordb+ GRAPHITI_FALKORDB_PORT: "6379"# Override Supabase URL for Docker networkSUPABASE_URL: http://kong:8000# Database connection string for Docker network@@ -74,6 +76,23 @@ services:interval: 10stimeout: 5sretries: 5+ falkordb:+ image: falkordb/falkordb:latest+ ports:+ - "6380:6379" # FalkorDB Redis protocol (6380 to avoid clash with Redis on 6379)+ - "3001:3000" # FalkorDB web UI+ environment:+ - REDIS_ARGS=--requirepass ${GRAPHITI_FALKORDB_PASSWORD:-}+ volumes:+ - falkordb_data:/data+ networks:+ - app-network+ healthcheck:+ test: ["CMD-SHELL", "redis-cli -p 6379 -a \"${GRAPHITI_FALKORDB_PASSWORD:-}\" --no-auth-warning ping && wget --spider -q http://localhost:3000 || exit 1"]+ interval: 10s+ timeout: 5s+ retries: 5+rabbitmq:image: rabbitmq:4.1.4container_name: rabbitmq@@ -374,6 +393,7 @@ services:AGPT_WS_SERVER_URL: ws://websocket_server:8001/wsvolumes:workspace-data:+ falkordb_data:networks:app-network:diff --git a/autogpt_platform/docker-compose.yml b/autogpt_platform/docker-compose.ymlindex 0a8b412d57..ef9c738834 100644--- a/autogpt_platform/docker-compose.yml+++ b/autogpt_platform/docker-compose.yml@@ -8,6 +8,7 @@ volumes:supabase-config:clamav-data:workspace-data:+ falkordb_data:x-agpt-services:&agpt-services@@ -36,6 +37,12 @@ services:file: ./docker-compose.platform.ymlservice: redis+ falkordb:+ <<: *agpt-services+ extends:+ file: ./docker-compose.platform.yml+ service: falkordb+rabbitmq:<<: *agpt-servicesextends:@@ -170,6 +177,7 @@ services:- redis- rabbitmq- clamav+ - falkordb- migratedeps_backend:diff --git a/autogpt_platform/frontend/src/app/api/openapi.json b/autogpt_platform/frontend/src/app/api/openapi.jsonindex 3f013c4509..f3e33f5697 100644--- a/autogpt_platform/frontend/src/app/api/openapi.json+++ b/autogpt_platform/frontend/src/app/api/openapi.json@@ -12543,7 +12543,9 @@"bash_exec","web_fetch","feature_request_search",- "feature_request_created"+ "feature_request_created",+ "memory_store",+ "memory_search"],"title": "ResponseType","description": "Types of tool responses."