:hedgehog: PostHog is the leading platform for building self-driving products. Our developer tools – AI observability, analytics, session replay, flags, experiments, error tracking, logs, and more – capture all the context agents need to diagnose problems, uncover opportunities, and ship fixes. Steer it all from Slack, web, desktop, or the MCP.
Python ab-testingai-analyticsanalyticscdpdata-warehouseexperimentsfeature-flagsjavascriptproduct-analyticspythonreactsession-replaysurveystypescriptweb-analytics
from typing import cast
import time_machine
from posthog.test.base import (
BaseTest,
ClickhouseTestMixin,
NonAtomicBaseTest,
_create_event,
_create_person,
flush_persons_and_events,
)
from unittest.mock import patch
from django.utils import timezone
from asgiref.sync import sync_to_async
from langchain_core.messages import (
AIMessage as LangchainAIMessage,
ToolMessage as LangchainToolMessage,
)
from langchain_core.runnables import RunnableLambda
from langgraph.errors import NodeInterrupt
from posthog.schema import AssistantMessage, ContextMessage, EventTaxonomyItem, HumanMessage
from products.posthog_ai.backend.models.assistant import CoreMemory
from ee.hogai.chat_agent.memory import prompts
from ee.hogai.chat_agent.memory.nodes import (
MemoryCollectorNode,
MemoryCollectorToolsNode,
MemoryInitializerContextMixin,
MemoryInitializerInterruptNode,
MemoryInitializerNode,
MemoryOnboardingEnquiryInterruptNode,
MemoryOnboardingEnquiryNode,
MemoryOnboardingFinalizeNode,
MemoryOnboardingNode,
)
from ee.hogai.core.agent_modes import SlashCommandName
from ee.hogai.utils.types import AssistantState, PartialAssistantState
class TestMemoryInitializerContextMixin(ClickhouseTestMixin, NonAtomicBaseTest):
CLASS_DATA_LEVEL_SETUP = False
def get_mixin(self):
class Mixin(MemoryInitializerContextMixin):
pass
mixin = Mixin()
mixin._team = self.team
mixin._user = self.user
return mixin
async def test_domain_retrieval(self):
# Use config mock to test _aretrieve_context logic without ClickHouse state leakage
mixin = self.get_mixin()
expected = EventTaxonomyItem(
property="$host", sample_values=["us.posthog.com", "eu.posthog.com"], sample_count=2
)
result = await mixin._aretrieve_context(config={"configurable": {"_mock_memory_onboarding_context": expected}})
self.assertEqual(result, expected)
async def test_app_bundle_id_retrieval(self):
# Use config mock to test _aretrieve_context logic without ClickHouse state leakage
mixin = self.get_mixin()
expected = EventTaxonomyItem(
property="$app_namespace", sample_values=["com.posthog.app", "com.posthog"], sample_count=2
)
result = await mixin._aretrieve_context(config={"configurable": {"_mock_memory_onboarding_context": expected}})
self.assertEqual(result, expected)
class TestMemoryOnboardingNode(ClickhouseTestMixin, NonAtomicBaseTest):
CLASS_DATA_LEVEL_SETUP = False
def _set_up_pageview_events(self):
_create_person(
distinct_ids=["person1"],
team=self.team,
)
_create_event(
event="$pageview",
distinct_id="person1",
team=self.team,
properties={"$host": "us.posthog.com"},
)
flush_persons_and_events()
def _set_up_app_bundle_id_events(self):
_create_person(
distinct_ids=["person1"],
team=self.team,
)
_create_event(
event="$screen",
distinct_id="person1",
team=self.team,
properties={"$app_namespace": "com.posthog.app"},
)
flush_persons_and_events()
async def test_should_run(self):
node = MemoryOnboardingNode(team=self.team, user=self.user)
self.assertEqual(
await node.should_run_onboarding_at_start(
AssistantState(messages=[HumanMessage(content=SlashCommandName.FIELD_INIT)])
),
"memory_onboarding",
)
core_memory = await CoreMemory.objects.acreate(team=self.team)
self.assertEqual(
await node.should_run_onboarding_at_start(AssistantState(messages=[HumanMessage(content="Hello")])),
"continue",
)
await core_memory.achange_status_to_pending()
self.assertEqual(
await node.should_run_onboarding_at_start(AssistantState(messages=[HumanMessage(content="Hello")])),
"continue",
)
await core_memory.achange_status_to_skipped()
self.assertEqual(
await node.should_run_onboarding_at_start(AssistantState(messages=[HumanMessage(content="Hello")])),
"continue",
)
async def test_should_run_with_empty_messages(self):
node = MemoryOnboardingNode(team=self.team, user=self.user)
self.assertEqual(await node.should_run_onboarding_at_start(AssistantState(messages=[])), "continue")
async def test_onboarding_message_explains_missing_events_when_no_pageviews(self):
await sync_to_async(flush_persons_and_events)()
node = MemoryOnboardingNode(team=self.team, user=self.user)
# Mock _aretrieve_context to return None (no events found) to avoid ClickHouse state leakage between tests
new_state = await node.arun(
AssistantState(messages=[HumanMessage(content="Hello")]),
{"configurable": {"_mock_memory_onboarding_context": None}},
)
new_state = cast(PartialAssistantState, new_state)
self.assertEqual(len(new_state.messages), 1)
self.assertTrue(isinstance(new_state.messages[0], AssistantMessage))
self.assertEqual(
cast(AssistantMessage, new_state.messages[0]).content,
prompts.ENQUIRY_NO_EVENTS_INITIAL_MESSAGE,
)
async def test_node_uses_project_description(self):
self.team.project.product_description = "This is a product analytics platform"
await sync_to_async(self.team.project.save)()
await sync_to_async(flush_persons_and_events)()
node = MemoryOnboardingNode(team=self.team, user=self.user)
# Mock _aretrieve_context to return None to avoid ClickHouse state leakage between tests
new_state = await node.arun(
AssistantState(messages=[HumanMessage(content="Hello")]),
{"configurable": {"_mock_memory_onboarding_context": None}},
)
new_state = cast(PartialAssistantState, new_state)
self.assertEqual(len(new_state.messages), 1)
self.assertTrue(isinstance(new_state.messages[0], AssistantMessage))
self.assertEqual(cast(AssistantMessage, new_state.messages[0]).content, prompts.ENQUIRY_INITIAL_MESSAGE)
core_memory = await CoreMemory.objects.aget(team=self.team)
self.assertEqual(
core_memory.initial_text,
"Question: What does the company do?\nAnswer: This is a product analytics platform",
)
async def test_node_starts_onboarding_for_pageview_events(self):
await sync_to_async(self._set_up_pageview_events)()
node = MemoryOnboardingNode(team=self.team, user=self.user)
new_state = await node.arun(AssistantState(messages=[HumanMessage(content="Hello")]), {})
assert new_state is not None and new_state.messages is not None
self.assertEqual(len(new_state.messages), 1)
self.assertTrue(isinstance(new_state.messages[0], AssistantMessage))
core_memory = await CoreMemory.objects.aget(team=self.team)
self.assertEqual(core_memory.scraping_status, CoreMemory.ScrapingStatus.PENDING)
self.assertIsNotNone(core_memory.scraping_started_at)
async def test_node_starts_onboarding_for_app_bundle_id_events(self):
await sync_to_async(self._set_up_app_bundle_id_events)()
node = MemoryOnboardingNode(team=self.team, user=self.user)
new_state = await node.arun(AssistantState(messages=[HumanMessage(content="Hello")]), {})
assert new_state is not None and new_state.messages is not None
self.assertEqual(len(new_state.messages), 1)
self.assertTrue(isinstance(new_state.messages[0], AssistantMessage))
core_memory = await CoreMemory.objects.aget(team=self.team)
self.assertEqual(core_memory.scraping_status, CoreMemory.ScrapingStatus.PENDING)
self.assertIsNotNone(core_memory.scraping_started_at)
class TestMemoryInitializerNode(ClickhouseTestMixin, NonAtomicBaseTest):
CLASS_DATA_LEVEL_SETUP = False
def setUp(self):
super().setUp()
self.core_memory = CoreMemory.objects.create(
team=self.team,
scraping_status=CoreMemory.ScrapingStatus.PENDING,
scraping_started_at=timezone.now(),
)
def _set_up_pageview_events(self):
_create_person(
distinct_ids=["person1"],
team=self.team,
)
_create_event(
event="$pageview",
distinct_id="person1",
team=self.team,
properties={"$host": "us.posthog.com"},
)
flush_persons_and_events()
def _set_up_app_bundle_id_events(self):
_create_person(
distinct_ids=["person1"],
team=self.team,
)
_create_event(
event="$screen",
distinct_id="person1",
team=self.team,
properties={"$app_namespace": "com.posthog.app"},
)
flush_persons_and_events()
def test_router_with_heres_what_i_found_scraping_message(self):
node = MemoryInitializerNode(team=self.team, user=self.user)
state = AssistantState(messages=[AssistantMessage(content="Here's what I found on acme.inc: ...")])
self.assertEqual(node.router(state), "interrupt") # We check for "Here's what I found" in the message content
def test_router_with_other_message(self):
node = MemoryInitializerNode(team=self.team, user=self.user)
state = AssistantState(messages=[AssistantMessage(content="Some other message")])
self.assertEqual(node.router(state), "continue")
async def test_run_with_url_based_initialization(self):
with patch.object(MemoryInitializerNode, "_model") as model_mock:
model_mock.return_value = RunnableLambda(lambda _: "PostHog is a product analytics platform.")
await sync_to_async(self._set_up_pageview_events)()
node = MemoryInitializerNode(team=self.team, user=self.user)
new_state = await node.arun(AssistantState(messages=[HumanMessage(content="Hello")]), {})
new_state = cast(PartialAssistantState, new_state)
self.assertEqual(len(new_state.messages), 1)
self.assertIsInstance(new_state.messages[0], AssistantMessage)
self.assertEqual(
cast(AssistantMessage, new_state.messages[0]).content,
"PostHog is a product analytics platform.",
)
core_memory = await CoreMemory.objects.aget(team=self.team)
self.assertEqual(core_memory.scraping_status, CoreMemory.ScrapingStatus.PENDING)
async def test_run_with_app_bundle_id_initialization(self):
with patch.object(MemoryInitializerNode, "_model") as model_mock:
model_mock.return_value = RunnableLambda(lambda _: "PostHog mobile app description.")
await sync_to_async(self._set_up_app_bundle_id_events)()
node = MemoryInitializerNode(team=self.team, user=self.user)
new_state = await node.arun(
AssistantState(messages=[HumanMessage(content="Hello")]),
{
"configurable": {
"_mock_memory_onboarding_context": EventTaxonomyItem(
property="$app_namespace", sample_values=["com.posthog.app"], sample_count=1
)
}
},
)
new_state = cast(PartialAssistantState, new_state)
self.assertEqual(len(new_state.messages), 1)
self.assertIsInstance(new_state.messages[0], AssistantMessage)
self.assertEqual(
cast(AssistantMessage, new_state.messages[0]).content,
"PostHog mobile app description.",
)
core_memory = await CoreMemory.objects.aget(team=self.team)
self.assertEqual(core_memory.scraping_status, CoreMemory.ScrapingStatus.PENDING)
async def test_memory_onboarding_runs_when_init_with_completed_memory(self):
"""Test that when /init is used and core memory is completed, the graph DOES run MemoryOnboardingNode"""
# Set the existing core memory to completed status
await self.core_memory.aset_core_memory("Some existing core memory")
memory_onboarding = MemoryOnboardingNode(team=self.team, user=self.user)
result = await memory_onboarding.should_run_onboarding_at_start(
AssistantState(messages=[HumanMessage(content=SlashCommandName.FIELD_INIT)])
)
# Should trigger memory onboarding flow (which includes MemoryOnboardingNode)
self.assertEqual(result, "memory_onboarding")
async def test_memory_onboarding_runs_when_init_with_nonexistent_memory(self):
"""Test that when /init is used and core memory doesn't exist, the graph DOES run MemoryOnboardingNode"""
# Delete the existing core memory
await self.core_memory.adelete()
memory_onboarding = MemoryOnboardingNode(team=self.team, user=self.user)
result = await memory_onboarding.should_run_onboarding_at_start(
AssistantState(messages=[HumanMessage(content=SlashCommandName.FIELD_INIT)])
)
# Should trigger memory onboarding flow (which includes MemoryInitializerNode)
self.assertEqual(result, "memory_onboarding")
async def test_memory_onboarding_does_not_run_when_init_with_pending_memory(self):
"""Test that when /init is used and core memory is pending, the graph does NOT run MemoryOnboardingNode"""
# The core memory from setUp() is already in PENDING status, so we can use it as-is
memory_onboarding = MemoryOnboardingNode(team=self.team, user=self.user)
result = await memory_onboarding.should_run_onboarding_at_start(
AssistantState(messages=[HumanMessage(content=SlashCommandName.FIELD_INIT)])
)
# Should NOT trigger memory onboarding flow, so MemoryOnboardingNode won't run
self.assertEqual(result, "continue")
class TestMemoryInitializerInterruptNode(ClickhouseTestMixin, NonAtomicBaseTest):
CLASS_DATA_LEVEL_SETUP = False
def setUp(self):
super().setUp()
self.core_memory = CoreMemory.objects.create(
team=self.team,
scraping_status=CoreMemory.ScrapingStatus.PENDING,
scraping_started_at=timezone.now(),
)
self.node = MemoryInitializerInterruptNode(team=self.team, user=self.user)
async def test_interrupt_when_not_resumed(self):
state = AssistantState(messages=[AssistantMessage(content="Product description")])
with self.assertRaises(NodeInterrupt) as e:
await self.node.arun(state, {})
interrupt_message = e.exception.args[0][0].value
self.assertIsInstance(interrupt_message, AssistantMessage)
self.assertEqual(interrupt_message.content, prompts.SCRAPING_VERIFICATION_MESSAGE)
self.assertIsNotNone(interrupt_message.meta)
self.assertEqual(len(interrupt_message.meta.form.options), 2)
self.assertEqual(interrupt_message.meta.form.options[0].value, prompts.SCRAPING_CONFIRMATION_MESSAGE)
self.assertEqual(interrupt_message.meta.form.options[1].value, prompts.SCRAPING_REJECTION_MESSAGE)
class TestMemoryOnboardingEnquiryNode(ClickhouseTestMixin, NonAtomicBaseTest):
CLASS_DATA_LEVEL_SETUP = False
def setUp(self):
super().setUp()
self.core_memory = CoreMemory.objects.create(team=self.team)
self.node = MemoryOnboardingEnquiryNode(team=self.team, user=self.user)
async def test_arouter_with_no_core_memory(self):
await sync_to_async(self.core_memory.delete)()
result = await self.node.arouter(AssistantState(messages=[]))
self.assertEqual(result, "continue")
self.assertTrue(await CoreMemory.objects.filter(team=self.team).aexists())
async def test_arouter_with_no_onboarding_question(self):
self.assertEqual(await self.node.arouter(AssistantState(messages=[])), "continue")
async def test_arouter_with_onboarding_question(self):
self.assertEqual(
await self.node.arouter(AssistantState(messages=[], onboarding_question="What is your target market?")),
"interrupt",
)
def test_format_question_with_separator(self):
question = "Some prefix===What is your target market?"
self.assertEqual(self.node._format_question(question), "What is your target market?")
def test_format_question_without_separator(self):
question = "What is your target market?"
self.assertEqual(self.node._format_question(question), question)
def test_format_question_with_markdown(self):
question = "**What** is your _target_ market?"
self.assertEqual(self.node._format_question(question), "What is your target market?")
async def test_run_with_initial_message(self):
with patch.object(MemoryOnboardingEnquiryNode, "_model") as model_mock:
model_mock.return_value = RunnableLambda(lambda _: "===What is your target market?")
state = AssistantState(
messages=[HumanMessage(content=SlashCommandName.FIELD_INIT)],
)
new_state = await self.node.arun(state, {})
self.assertEqual(new_state.onboarding_question, "What is your target market?")
await self.core_memory.arefresh_from_db()
self.assertEqual(self.core_memory.initial_text, "Question: What is your target market?\nAnswer:")
async def test_run_with_answer(self):
with patch.object(MemoryOnboardingEnquiryNode, "_model") as model_mock:
model_mock.return_value = RunnableLambda(lambda _: "===What is your pricing model?")
await self.core_memory.aappend_question_to_initial_text("What is your target market?")
state = AssistantState(
messages=[HumanMessage(content="We target enterprise customers")],
)
new_state = await self.node.arun(state, {})
self.assertEqual(new_state.onboarding_question, "What is your pricing model?")
await self.core_memory.arefresh_from_db()
self.assertEqual(
self.core_memory.initial_text,
"Question: What is your target market?\nAnswer: We target enterprise customers\nQuestion: What is your pricing model?\nAnswer:",
)
async def test_run_with_all_questions_answered(self):
with patch.object(MemoryOnboardingEnquiryNode, "_model") as model_mock:
def mock_response(input_dict):
input_str = str(input_dict)
if "You are tasked with gathering information" in input_str:
return "===What is your target market?"
return "[Done]"
model_mock.return_value = RunnableLambda(mock_response)
# First run - should get interrupted with first question
state = AssistantState(
messages=[HumanMessage(content=SlashCommandName.FIELD_INIT)],
)
new_state = await self.node.arun(state, {})
self.assertEqual(new_state.onboarding_question, "What is your target market?")
await self.core_memory.arefresh_from_db()
self.assertEqual(self.core_memory.initial_text, "Question: What is your target market?\nAnswer:")
# Second run - should complete since we have enough answers
await self.core_memory.aappend_question_to_initial_text("What is your pricing model?")
await self.core_memory.aappend_answer_to_initial_text("We use a subscription model")
await self.core_memory.aappend_question_to_initial_text("What is your target market?")
state = AssistantState(
messages=[HumanMessage(content="We target enterprise customers")],
)
new_state = await self.node.arun(state, {})
self.assertEqual(new_state, PartialAssistantState(onboarding_question=None))
async def test_memory_accepted(self):
with patch.object(MemoryOnboardingEnquiryNode, "_model") as model_mock:
def mock_response(input_dict):
input_str = str(input_dict)
if "You are tasked with gathering information" in input_str:
return "===What is your target market?"
return "[Done]"
model_mock.return_value = RunnableLambda(mock_response)
core_memory = await CoreMemory.objects.aget(team=self.team)
core_memory.initial_text = "Question: What does the company do?\nAnswer: Product description"
await core_memory.asave()
state = AssistantState(
messages=[
AssistantMessage(content="Product description"),
HumanMessage(content=prompts.SCRAPING_CONFIRMATION_MESSAGE),
],
)
new_state = await self.node.arun(state, {})
self.assertEqual(new_state.onboarding_question, "What is your target market?")
await core_memory.arefresh_from_db()
self.assertEqual(
core_memory.initial_text,
"Question: What does the company do?\nAnswer: Product description\nQuestion: What is your target market?\nAnswer:",
)
async def test_memory_rejected(self):
with patch.object(MemoryOnboardingEnquiryNode, "_model") as model_mock:
def mock_response(input_dict):
input_str = str(input_dict)
if "You are tasked with gathering information" in input_str:
return "===What is your target market?"
return "[Done]"
model_mock.return_value = RunnableLambda(mock_response)
core_memory = await CoreMemory.objects.aget(team=self.team)
core_memory.initial_text = "Question: What does the company do?\nAnswer: Product description"
await core_memory.asave()
state = AssistantState(
messages=[
AssistantMessage(content="Product description"),
HumanMessage(content=prompts.SCRAPING_REJECTION_MESSAGE),
],
graph_status="resumed",
)
new_state = await self.node.arun(state, {})
self.assertEqual(new_state.onboarding_question, "What is your target market?")
await core_memory.arefresh_from_db()
self.assertEqual(core_memory.initial_text, "Question: What is your target market?\nAnswer:")
class TestMemoryEnquiryInterruptNode(ClickhouseTestMixin, NonAtomicBaseTest):
CLASS_DATA_LEVEL_SETUP = False
def setUp(self):
super().setUp()
self.core_memory = CoreMemory.objects.create(team=self.team)
self.node = MemoryOnboardingEnquiryInterruptNode(team=self.team, user=self.user)
async def test_run(self):
with self.assertRaises(NodeInterrupt) as e:
await self.node.arun(
AssistantState(
messages=[AssistantMessage(content="What is your name?"), HumanMessage(content="Hello")],
onboarding_question="What is your target market?",
),
{},
)
self.assertEqual(len(e.exception.args[0]), 1)
self.assertIsInstance(e.exception.args[0][0].value, AssistantMessage)
self.assertEqual(e.exception.args[0][0].value.content, "What is your target market?")
new_state = await self.node.arun(
AssistantState(
messages=[AssistantMessage(content="What is your target market?"), HumanMessage(content="Hello")],
onboarding_question="What is your target market?",
),
{},
)
self.assertEqual(new_state, PartialAssistantState(onboarding_question=None))
class TestMemoryOnboardingFinalizeNode(ClickhouseTestMixin, NonAtomicBaseTest):
CLASS_DATA_LEVEL_SETUP = False
def setUp(self):
super().setUp()
self.core_memory = CoreMemory.objects.create(team=self.team)
self.node = MemoryOnboardingFinalizeNode(team=self.team, user=self.user)
async def test_run(self):
with patch.object(MemoryOnboardingFinalizeNode, "_model") as model_mock:
model_mock.return_value = RunnableLambda(lambda _: "Compressed memory about enterprise product")
self.core_memory.initial_text = "Question: What does the company do?\nAnswer: Product description"
await self.core_memory.asave()
new_state = await self.node.arun(AssistantState(messages=[]), {})
self.assertEqual(len(new_state.messages), 1)
self.assertIsInstance(new_state.messages[0], ContextMessage)
self.assertEqual(new_state.messages[0].id, new_state.root_conversation_start_id)
self.assertEqual(new_state.messages[0].id, new_state.start_id)
await self.core_memory.arefresh_from_db()
self.assertEqual(self.core_memory.text, "Compressed memory about enterprise product")
async def test_handles_json_content_in_memory(self):
"""Test that memory compression works when memory contains JSON with curly braces."""
json_memory_content = """Question: What kind of data structure do we use for events?
Answer: We use JSON like this:
{
"event": "user_signup",
"properties": {
"plan": "enterprise",
"source": "organic"
},
"timestamp": "2024-01-01T12:00:00Z"
}
Additional context: Our system also handles nested configurations like {"feature_flags": {"experiment_1": true, "experiment_2": false}}"""
with patch.object(MemoryOnboardingFinalizeNode, "_model") as model_mock:
model_mock.return_value = RunnableLambda(lambda _: "Company uses structured JSON for event tracking")
# This content contains JSON with curly braces that could be misinterpreted as template variables
self.core_memory.initial_text = json_memory_content
await self.core_memory.asave()
# This should not raise a KeyError about missing template variables
new_state = await self.node.arun(AssistantState(messages=[]), {})
self.assertEqual(len(new_state.messages), 1)
self.assertIsInstance(new_state.messages[0], ContextMessage)
await self.core_memory.arefresh_from_db()
self.assertEqual(self.core_memory.text, "Company uses structured JSON for event tracking")
class TestMemoryCollectorNode(ClickhouseTestMixin, NonAtomicBaseTest):
CLASS_DATA_LEVEL_SETUP = False
def setUp(self):
super().setUp()
self.core_memory = CoreMemory.objects.create(team=self.team)
self.core_memory.text = "Test product core memory"
self.core_memory.scraping_status = CoreMemory.ScrapingStatus.COMPLETED
self.core_memory.save()
self.node = MemoryCollectorNode(team=self.team, user=self.user)
def test_router(self):
# Test with no memory collection messages
state = AssistantState(messages=[HumanMessage(content="Text")], memory_collection_messages=None)
self.assertEqual(self.node.router(state), "next")
# Test with memory collection messages
state = AssistantState(
messages=[HumanMessage(content="Text")],
memory_collection_messages=[LangchainAIMessage(content="Memory message")],
)
self.assertEqual(self.node.router(state), "tools")
async def test_construct_messages(self):
# Test basic conversation reconstruction
state = AssistantState(
messages=[
HumanMessage(content="Question 1", id="0"),
AssistantMessage(content="Answer 1", id="1"),
HumanMessage(content="Question 2", id="2"),
],
start_id="2",
)
history = await self.node._aconstruct_messages(state)
self.assertEqual(len(history), 3)
self.assertEqual(history[0].content, "Question 1")
self.assertEqual(history[1].content, "Answer 1")
self.assertEqual(history[2].content, "Question 2")
# Test with memory collection messages
state = AssistantState(
messages=[HumanMessage(content="Question", id="0")],
memory_collection_messages=[
LangchainAIMessage(content="Memory 1"),
LangchainToolMessage(content="Tool response", tool_call_id="1"),
],
start_id="0",
)
history = await self.node._aconstruct_messages(state)
self.assertEqual(len(history), 3)
self.assertEqual(history[0].content, "Question")
self.assertEqual(history[1].content, "Memory 1")
self.assertEqual(history[2].content, "Tool response")
@time_machine.travel("2024-01-01", tick=False)
async def test_prompt_substitutions(self):
with patch.object(MemoryCollectorNode, "_model") as model_mock:
def assert_prompt(prompt):
messages = prompt.to_messages()
# Verify the structure of messages
self.assertEqual(len(messages), 3)
self.assertEqual(messages[0].type, "system")
self.assertEqual(messages[1].type, "human")
self.assertEqual(messages[2].type, "ai")
# Verify system message content
system_message = messages[0].content
self.assertIn("Test product core memory", system_message)
self.assertIn("2024-01-01", system_message)
# Verify conversation messages
self.assertEqual(messages[1].content, "We use a subscription model")
self.assertEqual(messages[2].content, "Memory message")
return LangchainAIMessage(content="[Done]")
model_mock.return_value = RunnableLambda(assert_prompt)
state = AssistantState(
messages=[
HumanMessage(content="We use a subscription model", id="0"),
],
memory_collection_messages=[
LangchainAIMessage(content="Memory message"),
],
start_id="0",
)
await self.node.arun(state, {})
async def test_exits_on_done_message(self):
with patch.object(MemoryCollectorNode, "_model") as model_mock:
model_mock.return_value = RunnableLambda(
lambda _: LangchainAIMessage(content="Processing complete. [Done]")
)
state = AssistantState(
messages=[HumanMessage(content="Text")],
memory_collection_messages=[LangchainAIMessage(content="Previous memory")],
)
new_state = await self.node.arun(state, {})
assert new_state is not None
self.assertEqual(new_state.memory_collection_messages, None)
async def test_appends_new_message(self):
with patch.object(MemoryCollectorNode, "_model") as model_mock:
model_mock.return_value = RunnableLambda(
lambda _: LangchainAIMessage(
content="New memory",
tool_calls=[
{
"name": "core_memory_append",
"args": {"new_fragment": "New memory"},
"id": "1",
},
],
),
)
state = AssistantState(
messages=[HumanMessage(content="Text")],
memory_collection_messages=[LangchainAIMessage(content="Previous memory")],
)
new_state = await self.node.arun(state, {})
assert new_state is not None and new_state.memory_collection_messages is not None
self.assertEqual(len(new_state.memory_collection_messages), 2)
self.assertEqual(new_state.memory_collection_messages[0].content, "Previous memory")
self.assertEqual(new_state.memory_collection_messages[1].content, "New memory")
async def test_construct_messages_typical_conversation(self):
# Set up a typical conversation with multiple interactions
state = AssistantState(
messages=[
HumanMessage(content="We use a subscription model", id="0"),
AssistantMessage(content="I'll note that down", id="1"),
HumanMessage(content="And we target enterprise customers", id="2"),
AssistantMessage(content="Let me process that information", id="3"),
HumanMessage(content="We also have a freemium tier", id="4"),
],
memory_collection_messages=[
LangchainAIMessage(content="Analyzing business model: subscription-based pricing."),
LangchainToolMessage(content="Memory appended.", tool_call_id="1"),
LangchainAIMessage(content="Analyzing target audience: enterprise customers."),
LangchainToolMessage(content="Memory appended.", tool_call_id="2"),
],
start_id="0",
)
history = await self.node._aconstruct_messages(state)
# Verify the complete conversation history is reconstructed correctly
self.assertEqual(len(history), 9) # 5 conversation messages + 4 memory messages
# Check conversation messages
self.assertEqual(history[0].content, "We use a subscription model")
self.assertEqual(history[1].content, "I'll note that down")
self.assertEqual(history[2].content, "And we target enterprise customers")
self.assertEqual(history[3].content, "Let me process that information")
self.assertEqual(history[4].content, "We also have a freemium tier")
# Check memory collection messages
self.assertEqual(history[5].content, "Analyzing business model: subscription-based pricing.")
self.assertEqual(history[6].content, "Memory appended.")
self.assertEqual(history[7].content, "Analyzing target audience: enterprise customers.")
self.assertEqual(history[8].content, "Memory appended.")
def test_check_tool_messages_are_valid_all_matching(self):
"""All tool calls have corresponding tool messages"""
messages = [
LangchainAIMessage(
content="Test",
tool_calls=[
{"id": "1", "name": "core_memory_append", "args": {}},
{"id": "2", "name": "core_memory_replace", "args": {}},
],
),
LangchainToolMessage(content="Done", tool_call_id="1"),
LangchainToolMessage(content="Done", tool_call_id="2"),
]
self.assertTrue(self.node._check_tool_messages_are_valid(messages))
def test_check_tool_messages_are_valid_missing_tool_message(self):
"""Tool call exists but no corresponding tool message"""
messages = [
LangchainAIMessage(
content="Test",
tool_calls=[
{"id": "1", "name": "core_memory_append", "args": {}},
{"id": "2", "name": "core_memory_replace", "args": {}},
],
),
LangchainToolMessage(content="Done", tool_call_id="1"),
]
self.assertFalse(self.node._check_tool_messages_are_valid(messages))
def test_check_tool_messages_are_valid_extra_tool_message(self):
"""Tool message exists but no corresponding tool call"""
messages = [
LangchainAIMessage(
content="Test",
tool_calls=[{"id": "1", "name": "core_memory_append", "args": {}}],
),
LangchainToolMessage(content="Done", tool_call_id="1"),
LangchainToolMessage(content="Extra", tool_call_id="2"),
]
self.assertFalse(self.node._check_tool_messages_are_valid(messages))
def test_check_tool_messages_are_valid_empty_messages(self):
"""Empty messages list"""
self.assertTrue(self.node._check_tool_messages_are_valid([]))
def test_check_tool_messages_are_valid_no_tool_calls(self):
"""Messages without any tool calls"""
messages = [
LangchainAIMessage(content="Test", tool_calls=[]),
LangchainAIMessage(content="Test 2", tool_calls=[]),
]
self.assertTrue(self.node._check_tool_messages_are_valid(messages))
async def test_skips_to_tools_if_has_incomplete_tool_calls(self):
"""If there are incomplete tool calls, skip the node."""
state = AssistantState(
messages=[
HumanMessage(content="We use a subscription model", id="0"),
],
memory_collection_messages=[
LangchainAIMessage(
content="Analyzing business model: subscription-based pricing.",
tool_calls=[
{
"id": "1",
"name": "core_memory_append",
"args": {"memory_content": "New memory fragment."},
}
],
),
],
start_id="0",
)
new_state = await self.node.arun(state, {})
self.assertIsNone(new_state)
self.assertEqual(self.node.router(state), "tools")
class TestMemoryCollectorToolsNode(BaseTest):
def setUp(self):
super().setUp()
self.core_memory = CoreMemory.objects.create(team=self.team)
self.core_memory.text = "Initial memory content"
self.core_memory.scraping_status = CoreMemory.ScrapingStatus.COMPLETED
self.core_memory.save()
self.node = MemoryCollectorToolsNode(team=self.team, user=self.user)
async def test_handles_correct_tools(self):
# Test handling a single append tool
state = AssistantState(
messages=[],
memory_collection_messages=[
LangchainAIMessage(
content="Adding new memory",
tool_calls=[
{
"name": "core_memory_append",
"args": {"memory_content": "New memory fragment."},
"id": "1",
},
{
"name": "core_memory_replace",
"args": {
"original_fragment": "Initial memory content",
"new_fragment": "New memory fragment 2.",
},
"id": "2",
},
],
)
],
)
new_state = await self.node.arun(state, {})
assert new_state is not None
assert new_state.memory_collection_messages is not None
self.assertEqual(len(new_state.memory_collection_messages), 3)
self.assertEqual(new_state.memory_collection_messages[1].type, "tool")
self.assertEqual(new_state.memory_collection_messages[1].content, "Memory appended.")
self.assertEqual(new_state.memory_collection_messages[2].type, "tool")
self.assertEqual(new_state.memory_collection_messages[2].content, "Memory replaced.")
async def test_handles_validation_error(self):
# Test handling validation error with incorrect tool arguments
state = AssistantState(
messages=[],
memory_collection_messages=[
LangchainAIMessage(
content="Invalid tool call",
tool_calls=[
{
"name": "core_memory_append",
"args": {"invalid_arg": "This will fail"},
"id": "1",
}
],
)
],
)
new_state = await self.node.arun(state, {})
assert new_state is not None
assert new_state.memory_collection_messages is not None
self.assertEqual(len(new_state.memory_collection_messages), 2)
self.assertNotIn("{{validation_error_message}}", new_state.memory_collection_messages[1].content)
async def test_handles_multiple_tools(self):
# Test handling multiple tool calls in a single message
state = AssistantState(
messages=[],
memory_collection_messages=[
LangchainAIMessage(
content="Multiple operations",
tool_calls=[
{
"name": "core_memory_append",
"args": {"memory_content": "First memory"},
"id": "1",
},
{
"name": "core_memory_append",
"args": {"memory_content": "Second memory"},
"id": "2",
},
{
"name": "core_memory_replace",
"args": {
"original_fragment": "Initial memory content",
"new_fragment": "Third memory",
},
"id": "3",
},
],
)
],
)
new_state = await self.node.arun(state, {})
assert new_state is not None
assert new_state.memory_collection_messages is not None
self.assertEqual(len(new_state.memory_collection_messages), 4)
self.assertEqual(new_state.memory_collection_messages[1].content, "Memory appended.")
self.assertEqual(new_state.memory_collection_messages[1].type, "tool")
self.assertEqual(new_state.memory_collection_messages[1].tool_call_id, "1") # type: ignore[attr-defined]
self.assertEqual(new_state.memory_collection_messages[2].content, "Memory appended.")
self.assertEqual(new_state.memory_collection_messages[2].type, "tool")
self.assertEqual(new_state.memory_collection_messages[2].tool_call_id, "2") # type: ignore[attr-defined]
self.assertEqual(new_state.memory_collection_messages[3].content, "Memory replaced.")
self.assertEqual(new_state.memory_collection_messages[3].type, "tool")
self.assertEqual(new_state.memory_collection_messages[3].tool_call_id, "3") # type: ignore[attr-defined]
await self.core_memory.arefresh_from_db()
self.assertEqual(self.core_memory.text, "Third memory\nFirst memory\nSecond memory")
async def test_handles_replacing_memory(self):
# Test replacing a memory fragment
state = AssistantState(
messages=[],
memory_collection_messages=[
LangchainAIMessage(
content="Replacing memory",
tool_calls=[
{
"name": "core_memory_replace",
"args": {
"original_fragment": "Initial memory",
"new_fragment": "Updated memory",
},
"id": "1",
}
],
)
],
)
new_state = await self.node.arun(state, {})
assert new_state is not None
assert new_state.memory_collection_messages is not None
self.assertEqual(len(new_state.memory_collection_messages), 2)
self.assertEqual(new_state.memory_collection_messages[1].content, "Memory replaced.")
self.assertEqual(new_state.memory_collection_messages[1].type, "tool")
self.assertEqual(new_state.memory_collection_messages[1].tool_call_id, "1") # type: ignore[attr-defined]
await self.core_memory.arefresh_from_db()
self.assertEqual(self.core_memory.text, "Updated memory content")
async def test_handles_replace_memory_not_found(self):
# Test replacing a memory fragment that doesn't exist
state = AssistantState(
messages=[],
memory_collection_messages=[
LangchainAIMessage(
content="Replacing non-existent memory",
tool_calls=[
{
"name": "core_memory_replace",
"args": {
"original_fragment": "Non-existent memory",
"new_fragment": "New memory",
},
"id": "1",
}
],
)
],
)
new_state = await self.node.arun(state, {})
assert new_state is not None
assert new_state.memory_collection_messages is not None
self.assertEqual(len(new_state.memory_collection_messages), 2)
content = new_state.memory_collection_messages[1].content
assert isinstance(content, str)
self.assertIn("not found", content.lower())
self.assertEqual(new_state.memory_collection_messages[1].type, "tool")
self.assertEqual(new_state.memory_collection_messages[1].tool_call_id, "1") # type: ignore[attr-defined]
await self.core_memory.arefresh_from_db()
self.assertEqual(self.core_memory.text, "Initial memory content")
async def test_handles_appending_new_memory(self):
# Test appending a new memory fragment
state = AssistantState(
messages=[],
memory_collection_messages=[
LangchainAIMessage(
content="Appending memory",
tool_calls=[
{
"name": "core_memory_append",
"args": {"memory_content": "Additional memory"},
"id": "1",
}
],
)
],
)
new_state = await self.node.arun(state, {})
assert new_state is not None
assert new_state.memory_collection_messages is not None
self.assertEqual(len(new_state.memory_collection_messages), 2)
self.assertEqual(new_state.memory_collection_messages[1].content, "Memory appended.")
self.assertEqual(new_state.memory_collection_messages[1].type, "tool")
await self.core_memory.arefresh_from_db()
self.assertEqual(self.core_memory.text, "Initial memory content\nAdditional memory")
async def test_error_when_no_memory_collection_messages(self):
# Test error when no memory collection messages are present
state = AssistantState(messages=[], memory_collection_messages=[])
with self.assertRaises(ValueError) as e:
await self.node.arun(state, {})
self.assertEqual(str(e.exception), "No memory collection messages found.")
async def test_error_when_last_message_not_ai(self):
# Test error when last message is not an AI message
state = AssistantState(
messages=[],
memory_collection_messages=[LangchainToolMessage(content="Not an AI message", tool_call_id="1")],
)
with self.assertRaises(ValueError) as e:
await self.node.arun(state, {})
self.assertEqual(str(e.exception), "Last message must be an AI message.")
async def test_creates_core_memory_when_missing(self):
# Test that core memory is created when it doesn't exist
await self.core_memory.adelete()
# Verify no core memory exists
self.assertFalse(await CoreMemory.objects.filter(team=self.team).aexists())
state = AssistantState(
messages=[],
memory_collection_messages=[
LangchainAIMessage(
content="Memory operation",
tool_calls=[
{
"name": "core_memory_append",
"args": {"memory_content": "New memory"},
"id": "1",
}
],
)
],
)
# Should not raise an error and should create core memory
new_state = await self.node.arun(state, {})
assert new_state is not None
# Verify core memory was created
self.assertTrue(await CoreMemory.objects.filter(team=self.team).aexists())
created_memory = await CoreMemory.objects.aget(team=self.team)
self.assertEqual(created_memory.text, "New memory")
# Verify response messages
assert new_state.memory_collection_messages is not None
self.assertEqual(len(new_state.memory_collection_messages), 2)
self.assertEqual(new_state.memory_collection_messages[1].content, "Memory appended.")
self.assertEqual(new_state.memory_collection_messages[1].type, "tool")
self.assertEqual(new_state.memory_collection_messages[1].tool_call_id, "1") # type: ignore[attr-defined]
async def test_creates_core_memory_when_missing_for_replace(self):
# Test that core memory is created when it doesn't exist, even for replace operations
await self.core_memory.adelete()
# Verify no core memory exists
self.assertFalse(await CoreMemory.objects.filter(team=self.team).aexists())
state = AssistantState(
messages=[],
memory_collection_messages=[
LangchainAIMessage(
content="Memory operation",
tool_calls=[
{
"name": "core_memory_replace",
"args": {
"original_fragment": "nonexistent",
"new_fragment": "New content",
},
"id": "1",
}
],
)
],
)
# Should not raise an error and should create core memory
new_state = await self.node.arun(state, {})
assert new_state is not None
# Verify core memory was created (empty since replace failed)
self.assertTrue(await CoreMemory.objects.filter(team=self.team).aexists())
created_memory = await CoreMemory.objects.aget(team=self.team)
self.assertEqual(created_memory.text, "") # Empty because replace of nonexistent fragment
# Verify response messages (replace should fail but not crash)
assert new_state.memory_collection_messages is not None
self.assertEqual(len(new_state.memory_collection_messages), 2)
self.assertIn("not found", new_state.memory_collection_messages[1].content)
self.assertEqual(new_state.memory_collection_messages[1].type, "tool")
self.assertEqual(new_state.memory_collection_messages[1].tool_call_id, "1") # type: ignore[attr-defined]
async def test_append_when_onboarding_memory_exists(self):
# Set up existing core memory with data from /init command
await self.core_memory.aappend_question_to_initial_text("What does PostHog do?")
await self.core_memory.aappend_answer_to_initial_text("PostHog is an analytics platform")
initial_text = self.core_memory.text
state = AssistantState(
messages=[],
memory_collection_messages=[
LangchainAIMessage(
content="Memory operation",
tool_calls=[
{
"name": "core_memory_append",
"args": {"memory_content": "New insight about user behavior"},
"id": "1",
}
],
)
],
)
new_state = await self.node.arun(state, {})
assert new_state is not None
# Verify memory was appended to existing content
await self.core_memory.arefresh_from_db()
expected_text = initial_text + "\nNew insight about user behavior"
self.assertEqual(self.core_memory.text, expected_text)
# Verify no new core memory was created (still same record)
self.assertEqual(await CoreMemory.objects.filter(team=self.team).acount(), 1)
# Verify response messages
assert new_state.memory_collection_messages is not None
self.assertEqual(len(new_state.memory_collection_messages), 2)
self.assertEqual(new_state.memory_collection_messages[1].content, "Memory appended.")
self.assertEqual(new_state.memory_collection_messages[1].type, "tool")
self.assertEqual(new_state.memory_collection_messages[1].tool_call_id, "1") # type: ignore[attr-defined]