Skip to content

Compress tool outputs, logs, files, and RAG chunks before they reach the LLM. 20% fewer tokens for coding agents, 60-95% fewer tokens for JSON, same answers. Library, proxy, MCP server.

refactor(memory): drop the unused extraction prompts and tool schemas (#4100)

Tejas Chopra6d23895dc003
diff --git a/headroom/memory/extraction.py b/headroom/memory/extraction.py
index 62dc6e9bb..059fa27c0 100644
--- a/headroom/memory/extraction.py
+++ b/headroom/memory/extraction.py
@@ -1,154 +1,14 @@
-"""Memory extraction prompts and utilities.
+"""Memory extraction system prompt.
-This module contains extraction prompts derived from Mem0's internal prompts,
-adapted for use with Headroom's memory system. By using these prompts in the
-main LLM, we can extract facts/entities/relationships in a SINGLE pass,
-avoiding the double LLM calls that occur when Mem0 does its own extraction.
-
-Architecture:
- Traditional Mem0 flow (INEFFICIENT):
- User → Main LLM → memory_save(content) → Mem0.add() → Mem0 LLM extracts facts
- → Mem0 LLM extracts entities
- → Mem0 LLM extracts relationships
- Total: 3-4 LLM calls per memory save!
-
- Optimized Headroom flow (EFFICIENT):
- User → Main LLM (with extraction prompts) → memory_save(facts, entities, relationships)
- → Direct write to Qdrant + Neo4j
- Total: 1 LLM call per memory save!
-
-Usage:
- # Option 1: Inline extraction via tool schema
- # The main LLM extracts facts/entities when calling memory_save
- # See MEMORY_SAVE_TOOL_WITH_EXTRACTION for the enhanced tool schema
-
- # Option 2: System prompt injection
- # Add EXTRACTION_SYSTEM_PROMPT to your main LLM's system prompt
- # The LLM will output structured extraction in its response
+``EXTRACTION_SYSTEM_PROMPT`` is injected into the main LLM's system prompt by
+``with_memory_tools(..., optimized=True)`` so the model pre-extracts facts,
+entities and relationships when it calls ``memory_save``. Backends that accept
+those fields (``DirectMem0Adapter``) then write them directly instead of
+running their own LLM extraction.
"""
from __future__ import annotations
-from typing import Any
-
-# =============================================================================
-# Fact Extraction Prompt (for Vector Store)
-# Generic, balanced prompt - not too specific, not too broad
-# =============================================================================
-
-FACT_EXTRACTION_PROMPT = """You are a comprehensive fact extractor. Your goal is to capture ALL meaningful information from conversations as discrete, searchable facts.
-
-CORE PRINCIPLES:
-
-1. **Comprehensiveness**: Extract EVERY fact, not just obvious ones. If in doubt, extract it.
-
-2. **Attribution**: Every fact MUST include WHO it's about. Use actual names, never "user" or "I".
- - Good: "Alice prefers tea over coffee"
- - Bad: "Prefers tea over coffee"
-
-3. **Specificity**: Use exact terms from the conversation, not vague paraphrases.
- - Good: "Bob does pottery and running to destress"
- - Bad: "Bob enjoys art and exercise"
-
-4. **Self-contained**: Each fact should be understandable on its own.
- - Good: "Carol's sister Emma works at Google"
- - Bad: "Sister works at Google"
-
-5. **Temporal grounding**: When dates are mentioned (explicitly or relative to a known date), include the resolved date.
- - If "last year" is mentioned and the conversation is from 2023, say "in 2022"
- - If "yesterday" is mentioned and the date is May 7, say "on May 6"
-
-WHAT TO EXTRACT:
-- Personal details (identity, background, relationships, important dates)
-- Preferences and opinions (likes, dislikes, choices)
-- Activities and hobbies (specific activities, not categories)
-- Professional information (job, company, skills, goals)
-- Events and experiences (trips, meetings, milestones)
-- Plans and intentions (future events, goals)
-- Health and wellness (restrictions, routines, conditions)
-
-WHAT NOT TO EXTRACT:
-- Greetings and small talk
-- Transient information ("I'm going to make coffee")
-- Sensitive data (passwords, financial details)
-- Duplicate information already captured
-
-OUTPUT: Return a list of discrete fact strings, each complete and self-contained.
-"""
-
-# =============================================================================
-# Entity Extraction Prompt (for Graph Store)
-# Derived from Mem0's entity extraction system prompt
-# =============================================================================
-
-ENTITY_EXTRACTION_PROMPT = """You are a smart assistant who understands entities and their types in a given text.
-
-Guidelines:
-- Extract all named entities (people, organizations, products, technologies, locations, etc.)
-- Assign appropriate entity types to each
-- If the text contains self-references ('I', 'me', 'my'), use the user_id as the entity
-- Do NOT answer questions - only extract entities
-
-Entity Types to consider:
-- person: Individual people (names, roles)
-- organization: Companies, teams, departments
-- technology: Programming languages, frameworks, tools, services
-- location: Cities, countries, buildings, rooms
-- project: Named projects, initiatives
-- concept: Abstract concepts, topics, domains
-- product: Software products, hardware, services
-- event: Meetings, conferences, deadlines
-
-Example:
-- Input: "I work at Acme Corp using Python and TensorFlow"
- Entities: [
- {"entity": "user_id", "entity_type": "person"},
- {"entity": "Acme Corp", "entity_type": "organization"},
- {"entity": "Python", "entity_type": "technology"},
- {"entity": "TensorFlow", "entity_type": "technology"}
- ]
-"""
-
-# =============================================================================
-# Relationship Extraction Prompt (for Graph Store)
-# Derived from Mem0's EXTRACT_RELATIONS_PROMPT
-# =============================================================================
-
-RELATIONSHIP_EXTRACTION_PROMPT = """You are an advanced algorithm designed to extract structured relationships from text to construct knowledge graphs.
-
-Guidelines:
-1. Extract only explicitly stated relationships from the text
-2. Use the user_id as the source entity for self-references ('I', 'me', 'my')
-3. Use consistent, general, and timeless relationship types
- - Prefer "works_at" over "started_working_at"
- - Prefer "uses" over "recently_started_using"
-4. Only establish relationships among entities explicitly mentioned
-
-Relationship Format:
-{
- "source": "entity name",
- "relationship": "relationship_type",
- "destination": "entity name"
-}
-
-Common Relationship Types:
-- works_at, employed_by
-- uses, prefers, likes, dislikes
-- knows, collaborates_with, reports_to
-- located_in, based_in
-- part_of, belongs_to, member_of
-- created, owns, maintains
-- depends_on, requires, integrates_with
-
-Example:
-- Input: "I work at Netflix and use Python daily. Alice is my manager."
- Relationships: [
- {"source": "user_id", "relationship": "works_at", "destination": "Netflix"},
- {"source": "user_id", "relationship": "uses", "destination": "Python"},
- {"source": "Alice", "relationship": "manages", "destination": "user_id"}
- ]
-"""
-
# =============================================================================
# Combined Extraction System Prompt
# For injecting into the main LLM's system prompt
@@ -172,375 +32,3 @@ For each piece of information worth saving, extract:
- Format: [{"source": "entity1", "relationship": "rel_type", "destination": "entity2"}]
When calling memory_save, include these pre-extracted fields to optimize storage."""
-
-
-# =============================================================================
-# Generic Conversation Extraction Prompt
-# Balanced: not too specific, not too broad
-# Works with any domain, any speakers
-# =============================================================================
-
-
-def get_conversation_extraction_prompt(
- speaker_names: list[str] | None = None,
- context_date: str | None = None,
-) -> str:
- """Generate a balanced conversation extraction prompt.
-
- This prompt is designed following research from Mem0, MemMachine, and ChatExtract:
- - Uses atomic fact decomposition (single-fact units)
- - Includes categorical structure (preference/fact/context)
- - Has importance scoring guidance
- - Provides few-shot examples for format clarity
- - Strong temporal grounding when date context is provided
- - Entity attribution rules
-
- The key balance: Generic enough for any domain, specific enough for comprehensive extraction.
-
- Args:
- speaker_names: Optional list of speaker names for attribution guidance
- context_date: Optional date string for temporal context (e.g., "May 7, 2023")
-
- Returns:
- A system prompt for conversation fact extraction
- """
- # Build speaker context
- speakers_section = ""
- example_speaker = "Alice"
- if speaker_names and len(speaker_names) >= 1:
- example_speaker = speaker_names[0]
- names = ", ".join(speaker_names)
- speakers_section = f"""
-SPEAKERS: {names}
-Use their actual names in every fact (never "user", "I", or "they")."""
-
- # Build temporal context - this is CRITICAL for accuracy
- temporal_section = ""
- if context_date:
- temporal_section = f"""
-TEMPORAL CONTEXT: This conversation is from {context_date}.
-Convert ALL relative dates to absolute dates:
-- "last year" → the year before {context_date}
-- "yesterday" → the day before {context_date}
-- "last week" → approximately one week before {context_date}
-- "next month" → the month after {context_date}
-- "recently" → estimate based on {context_date}
-
-IMPORTANT: Store the resolved absolute date, not the relative phrase."""
-
- return f"""You are a memory extraction system. Analyze the conversation and extract facts worth remembering for future retrieval.
-{speakers_section}{temporal_section}
-
-WHAT TO EXTRACT (Categories):
-
-1. **IDENTITY & CHARACTERISTICS** - Who people ARE (most important!)
- - Gender identity, relationship status, nationality, ethnicity, age
- - "X is a transgender woman", "X is single", "X is from Sweden"
- - Personal traits, backgrounds, defining characteristics
-
-2. **PREFERENCES** - Likes, dislikes, choices, opinions
- - "X prefers Y over Z", "X likes Y", "X dislikes Z"
-
-3. **ACTIVITIES & HOBBIES** - Specific things people DO (be specific!)
- - "X does pottery", "X runs marathons", "X plays violin"
- - NOT vague: "X likes art" - be specific about WHAT activities
-
-4. **RELATIONSHIPS** - How people relate to each other
- - Family: "X's sister is Y", "X is married to Y"
- - Professional: "X works at Y", "X's manager is Y"
-
-5. **EVENTS WITH DATES** - Things that happened (always include WHEN)
- - "X attended Y on [date]", "X visited Y in [month/year]"
-
-6. **PLANS & GOALS** - Future intentions
- - "X is planning to...", "X wants to..."
-
-EXTRACTION FORMAT:
-
-For each meaningful segment, call memory_save with:
-- **content**: Brief summary
-- **importance**: Score from 0.0 to 1.0
- - 0.3-0.4: Background info (minor details)
- - 0.5-0.6: Useful info (preferences, context)
- - 0.7-0.8: Important info (key facts, relationships)
- - 0.9-1.0: Critical info (identity, major events)
-- **facts**: List of atomic facts (see format below)
-- **extracted_entities**: [{{"entity": "name", "entity_type": "person|organization|location|technology|event|project"}}]
-- **extracted_relationships**: [{{"source": "entity1", "relationship": "rel_type", "destination": "entity2"}}]
-
-ATOMIC FACT FORMAT:
-Each fact must be a complete, self-contained statement: [WHO] [WHAT] [WHEN/WHERE if applicable]
-
-✓ GOOD: "{example_speaker} is a software engineer at Netflix"
-✗ BAD: "Is a software engineer" (missing WHO)
-
-✓ GOOD: "{example_speaker} visited Paris in June 2023"
-✗ BAD: "{example_speaker} went somewhere recently" (too vague, relative date)
-
-✓ GOOD: "{example_speaker} prefers Python over JavaScript for backend work"
-✗ BAD: "{example_speaker} likes programming" (too vague, lost specificity)
-
-RELATIONSHIP TYPES:
-Use consistent types: works_at, lives_in, knows, manages, reports_to, married_to, sibling_of, friend_of, prefers, uses, attended, visited, member_of, created, owns, collects, studies, plays
-
-CRITICAL - RELATIONSHIP EXTRACTION:
-Relationships enable multi-hop reasoning. Extract relationships whenever:
-- Two PEOPLE are connected (family, friends, colleagues, manager/report)
-- A person USES/OWNS/COLLECTS something
-- A person WORKS AT/STUDIES AT an organization
-- A person LIVES IN/VISITED a location
-- A person ATTENDS/MEMBER OF a group or event
-- A person LIKES/PREFERS/INTERESTED IN a topic or thing
-
-FEW-SHOT EXAMPLES:
-
-Input: "{example_speaker}: I moved to Tokyo last year for my job at Sony. My colleague Kenji has been showing me around."
-Output: {{
- "content": "{example_speaker} relocated to Tokyo for work",
- "importance": 0.8,
- "facts": ["{example_speaker} moved to Tokyo", "{example_speaker} works at Sony", "{example_speaker}'s colleague is Kenji", "Kenji shows {example_speaker} around Tokyo"],
- "extracted_entities": [{{"entity": "{example_speaker}", "entity_type": "person"}}, {{"entity": "Tokyo", "entity_type": "location"}}, {{"entity": "Sony", "entity_type": "organization"}}, {{"entity": "Kenji", "entity_type": "person"}}],
- "extracted_relationships": [{{"source": "{example_speaker}", "relationship": "lives_in", "destination": "Tokyo"}}, {{"source": "{example_speaker}", "relationship": "works_at", "destination": "Sony"}}, {{"source": "{example_speaker}", "relationship": "knows", "destination": "Kenji"}}]
-}}
-
-Input: "{example_speaker}: My brother Tom is a chef and he's obsessed with Italian cuisine. He studied in Rome for two years."
-Output: {{
- "content": "{example_speaker}'s brother Tom's career",
- "importance": 0.7,
- "facts": ["{example_speaker}'s brother is Tom", "Tom is a chef", "Tom specializes in Italian cuisine", "Tom studied cooking in Rome for two years"],
- "extracted_entities": [{{"entity": "{example_speaker}", "entity_type": "person"}}, {{"entity": "Tom", "entity_type": "person"}}, {{"entity": "Rome", "entity_type": "location"}}],
- "extracted_relationships": [{{"source": "{example_speaker}", "relationship": "sibling_of", "destination": "Tom"}}, {{"source": "Tom", "relationship": "specializes_in", "destination": "Italian cuisine"}}, {{"source": "Tom", "relationship": "studied_in", "destination": "Rome"}}]
-}}
-
-Input: "{example_speaker}: I've been learning Spanish on Duolingo. I want to visit Mexico next summer with my family."
-Output: {{
- "content": "{example_speaker}'s language learning and travel plans",
- "importance": 0.6,
- "facts": ["{example_speaker} is learning Spanish", "{example_speaker} uses Duolingo", "{example_speaker} plans to visit Mexico next summer", "{example_speaker} wants to travel with family"],
- "extracted_entities": [{{"entity": "{example_speaker}", "entity_type": "person"}}, {{"entity": "Spanish", "entity_type": "concept"}}, {{"entity": "Duolingo", "entity_type": "technology"}}, {{"entity": "Mexico", "entity_type": "location"}}],
- "extracted_relationships": [{{"source": "{example_speaker}", "relationship": "learning", "destination": "Spanish"}}, {{"source": "{example_speaker}", "relationship": "uses", "destination": "Duolingo"}}, {{"source": "{example_speaker}", "relationship": "plans_to_visit", "destination": "Mexico"}}]
-}}
-
-Input: "{example_speaker}: I prefer working from home. I find I'm more productive without the office distractions."
-Output: {{
- "content": "{example_speaker}'s work preference",
- "importance": 0.6,
- "facts": ["{example_speaker} prefers working from home", "{example_speaker} finds home more productive than office", "{example_speaker} dislikes office distractions"],
- "extracted_entities": [{{"entity": "{example_speaker}", "entity_type": "person"}}],
- "extracted_relationships": [{{"source": "{example_speaker}", "relationship": "prefers", "destination": "working from home"}}]
-}}
-
-FILTERING:
-- DO extract: preferences, facts, context, events, relationships
-- DO NOT extract: greetings ("Hi!", "How are you?"), transient info ("I'm making coffee"), sensitive data (passwords, keys)
-
-If nothing worth remembering, do not call memory_save."""
-
-
-# Preset prompts for common use cases
-CONVERSATION_EXTRACTION_PROMPT_BASIC = get_conversation_extraction_prompt()
-
-
-def get_memory_answer_prompt(speaker_names: list[str] | None = None) -> str:
- """Generate a balanced answer prompt for memory-based Q&A.
-
- Based on research findings:
- - Use exact terms from memories (no paraphrasing to vague terms)
- - Be concise (shortest accurate answer)
- - Know when to say "Information not found"
-
- Args:
- speaker_names: Optional list of speaker names for context
-
- Returns:
- A system prompt for answering questions from memories
- """
- context = ""
- if speaker_names:
- names = " and ".join(speaker_names)
- context = f" about {names}"
-
- return f"""You are answering questions{context} using a memory system.
-
-PROCESS:
-1. Use memory_search to find relevant memories
-2. Answer based on what the memories contain
-3. For inference questions (would/could/likely), reason from memories + common knowledge
-
-ANSWER RULES:
-- Be CONCISE but include the key information
-- Use SPECIFIC terms from memories (not vague paraphrases)
-- For dates: give the actual date from memory
-- For names: give the actual name from memory
-- For yes/no: give your conclusion with brief supporting evidence
-
-INFERENCE QUESTIONS (would, could, likely, might):
-Use memories as evidence and apply common knowledge to reason:
-- Memory: "enjoys mystery novels" → Q: "Would they like Agatha Christie?" → "Yes, Agatha Christie is a famous mystery author"
-- Memory: "interested in space exploration" → Q: "Would they know about the Mars rover?" → "Yes, Mars missions are central to space exploration"
-- Memory: "is a vegetarian" → Q: "Can they eat cheese?" → "Yes, vegetarians can eat dairy products"
-
-If no relevant information found: "Information not found"
-
-Answer directly and concisely."""
-
-
-# =============================================================================
-# Enhanced Memory Save Tool Schema
-# Includes pre-extraction fields for optimized storage
-# =============================================================================
-
-MEMORY_SAVE_TOOL_WITH_EXTRACTION: dict[str, Any] = {
- "type": "function",
- "function": {
- "name": "memory_save",
- "description": """Save important information to long-term memory with optional pre-extraction.
-
-When you extract facts, entities, and relationships yourself (recommended for efficiency),
-include them in the tool call. This bypasses redundant LLM extraction in the storage backend.
-
-DO save:
-- User preferences, personal facts, project context, decisions, relationships
-- Pre-extracted facts as discrete, self-contained statements
-- Entities with their types (person, organization, technology, etc.)
-- Relationships between entities (source, relationship, destination)
-
-DO NOT save:
-- Transient information, sensitive data (passwords, keys), redundant info""",
- "parameters": {
- "type": "object",
- "properties": {
- "content": {
- "type": "string",
- "description": "The original information/context to remember. Used as fallback if no facts provided.",
- },
- "importance": {
- "type": "number",
- "minimum": 0.0,
- "maximum": 1.0,
- "description": "Importance score: 0.9-1.0 critical, 0.7-0.8 important, 0.5-0.6 useful, 0.3-0.4 background",
- },
- "facts": {
- "type": "array",
- "items": {"type": "string"},
- "description": "Pre-extracted discrete facts. Each fact should be self-contained. Example: ['Uses Python for backend', 'Prefers dark mode']",
- },
- "extracted_entities": {
- "type": "array",
- "items": {
- "type": "object",
- "properties": {
- "entity": {"type": "string", "description": "Entity name"},
- "entity_type": {
- "type": "string",
- "description": "Type: person, organization, technology, location, project, concept, product, event",
- },
- },
- "required": ["entity", "entity_type"],
- },
- "description": "Pre-extracted entities with types for graph storage.",
- },
- "extracted_relationships": {
- "type": "array",
- "items": {
- "type": "object",
- "properties": {
- "source": {"type": "string", "description": "Source entity name"},
- "relationship": {
- "type": "string",
- "description": "Relationship type (e.g., works_at, uses, knows, manages)",
- },
- "destination": {
- "type": "string",
- "description": "Destination entity name",
- },
- },
- "required": ["source", "relationship", "destination"],
- },
- "description": "Pre-extracted relationships between entities for graph storage.",
- },
- },
- "required": ["content", "importance"],
- },
- },
-}
-
-
-def get_extraction_tools() -> list[dict[str, Any]]:
- """Get tool definitions for standalone extraction (if needed).
-
- These tools can be used to have an LLM extract facts/entities/relationships
- in a separate call, similar to how Mem0 does it internally.
-
- For most use cases, prefer using MEMORY_SAVE_TOOL_WITH_EXTRACTION
- which combines extraction with storage in a single tool call.
- """
- return [
- {
- "type": "function",
- "function": {
- "name": "extract_facts",
- "description": "Extract discrete facts from text for memory storage.",
- "parameters": {
- "type": "object",
- "properties": {
- "facts": {
- "type": "array",
- "items": {"type": "string"},
- "description": "List of discrete, self-contained facts extracted from the text.",
- }
- },
- "required": ["facts"],
- },
- },
- },
- {
- "type": "function",
- "function": {
- "name": "extract_entities",
- "description": "Extract entities and their types from text.",
- "parameters": {
- "type": "object",
- "properties": {
- "entities": {
- "type": "array",
- "items": {
- "type": "object",
- "properties": {
- "entity": {"type": "string"},
- "entity_type": {"type": "string"},
- },
- "required": ["entity", "entity_type"],
- },
- }
- },
- "required": ["entities"],
- },
- },
- },
- {
- "type": "function",
- "function": {
- "name": "extract_relationships",
- "description": "Extract relationships between entities from text.",
- "parameters": {
- "type": "object",
- "properties": {
- "relationships": {
- "type": "array",
- "items": {
- "type": "object",
- "properties": {
- "source": {"type": "string"},
- "relationship": {"type": "string"},
- "destination": {"type": "string"},
- },
- "required": ["source", "relationship", "destination"],
- },
- }
- },
- "required": ["relationships"],
- },
- },
- },
- ]
diff --git a/tests/test_memory/test_extraction.py b/tests/test_memory/test_extraction.py
index 3387bfcab..0705cd295 100644
--- a/tests/test_memory/test_extraction.py
+++ b/tests/test_memory/test_extraction.py
@@ -1,157 +1,8 @@
-"""Tests for memory extraction prompts and utilities.
-
-Tests the extraction prompts, prompt generators, and tool schemas
-used for inline fact/entity/relationship extraction.
-"""
+"""Tests for the memory extraction system prompt."""
from __future__ import annotations
-from headroom.memory.extraction import (
- CONVERSATION_EXTRACTION_PROMPT_BASIC,
- ENTITY_EXTRACTION_PROMPT,
- EXTRACTION_SYSTEM_PROMPT,
- FACT_EXTRACTION_PROMPT,
- MEMORY_SAVE_TOOL_WITH_EXTRACTION,
- RELATIONSHIP_EXTRACTION_PROMPT,
- get_conversation_extraction_prompt,
- get_extraction_tools,
- get_memory_answer_prompt,
-)
-
-# =============================================================================
-# Test Prompt Constants
-# =============================================================================
-
-
-class TestFactExtractionPrompt:
- """Tests for FACT_EXTRACTION_PROMPT constant."""
-
- def test_prompt_is_non_empty_string(self):
- """Prompt should be a non-empty string."""
- assert isinstance(FACT_EXTRACTION_PROMPT, str)
- assert len(FACT_EXTRACTION_PROMPT) > 0
-
- def test_prompt_contains_key_instructions(self):
- """Prompt should contain key extraction instructions."""
- prompt = FACT_EXTRACTION_PROMPT
-
- # Core principles
- assert "Comprehensiveness" in prompt
- assert "Attribution" in prompt
- assert "Specificity" in prompt
- assert "Self-contained" in prompt
- assert "Temporal grounding" in prompt
-
- def test_prompt_contains_extraction_categories(self):
- """Prompt should list what to extract."""
- prompt = FACT_EXTRACTION_PROMPT
-
- assert "Personal details" in prompt
- assert "Preferences" in prompt
- assert "Activities" in prompt or "hobbies" in prompt.lower()
- assert "Professional" in prompt
- assert "Events" in prompt
- assert "Plans" in prompt
-
- def test_prompt_contains_filtering_guidance(self):
- """Prompt should explain what NOT to extract."""
- prompt = FACT_EXTRACTION_PROMPT
-
- assert "WHAT NOT TO EXTRACT" in prompt
- assert "Greetings" in prompt
- assert "Transient" in prompt
- assert "Sensitive data" in prompt
-
- def test_prompt_has_good_bad_examples(self):
- """Prompt should include good/bad examples for clarity."""
- prompt = FACT_EXTRACTION_PROMPT
-
- assert "Good:" in prompt
- assert "Bad:" in prompt
-
-
-class TestEntityExtractionPrompt:
- """Tests for ENTITY_EXTRACTION_PROMPT constant."""
-
- def test_prompt_is_non_empty_string(self):
- """Prompt should be a non-empty string."""
- assert isinstance(ENTITY_EXTRACTION_PROMPT, str)
- assert len(ENTITY_EXTRACTION_PROMPT) > 0
-
- def test_prompt_contains_entity_types(self):
- """Prompt should define common entity types."""
- prompt = ENTITY_EXTRACTION_PROMPT
-
- assert "person" in prompt
- assert "organization" in prompt
- assert "technology" in prompt
- assert "location" in prompt
- assert "project" in prompt
-
- def test_prompt_handles_self_references(self):
- """Prompt should explain how to handle self-references."""
- prompt = ENTITY_EXTRACTION_PROMPT
-
- # Should mention I/me/my handling
- assert "self-references" in prompt.lower() or "'I'" in prompt or "'me'" in prompt
- assert "user_id" in prompt
-
- def test_prompt_contains_example(self):
- """Prompt should include usage example."""
- prompt = ENTITY_EXTRACTION_PROMPT
-
- assert "Example:" in prompt
- assert "Input:" in prompt
- assert "Entities:" in prompt
-
-
-class TestRelationshipExtractionPrompt:
- """Tests for RELATIONSHIP_EXTRACTION_PROMPT constant."""
-
- def test_prompt_is_non_empty_string(self):
- """Prompt should be a non-empty string."""
- assert isinstance(RELATIONSHIP_EXTRACTION_PROMPT, str)
- assert len(RELATIONSHIP_EXTRACTION_PROMPT) > 0
-
- def test_prompt_contains_guidelines(self):
- """Prompt should contain extraction guidelines."""
- prompt = RELATIONSHIP_EXTRACTION_PROMPT
-
- assert "Guidelines" in prompt
- assert "explicitly stated" in prompt.lower()
-
- def test_prompt_defines_relationship_format(self):
- """Prompt should define relationship format."""
- prompt = RELATIONSHIP_EXTRACTION_PROMPT
-
- assert "Relationship Format" in prompt
- assert "source" in prompt
- assert "relationship" in prompt
- assert "destination" in prompt
-
- def test_prompt_lists_common_relationship_types(self):
- """Prompt should list common relationship types."""
- prompt = RELATIONSHIP_EXTRACTION_PROMPT
-
- assert "works_at" in prompt
- assert "uses" in prompt
- assert "knows" in prompt
- assert "collaborates_with" in prompt or "reports_to" in prompt
-
- def test_prompt_prefers_timeless_relationships(self):
- """Prompt should prefer timeless relationship types."""
- prompt = RELATIONSHIP_EXTRACTION_PROMPT
-
- # Should prefer "works_at" over "started_working_at"
- assert "timeless" in prompt.lower()
- assert "works_at" in prompt and "started_working_at" in prompt
-
- def test_prompt_contains_example(self):
- """Prompt should include usage example."""
- prompt = RELATIONSHIP_EXTRACTION_PROMPT
-
- assert "Example:" in prompt
- assert "Relationships:" in prompt
+from headroom.memory.extraction import EXTRACTION_SYSTEM_PROMPT
class TestExtractionSystemPrompt:
@@ -186,645 +37,3 @@ class TestExtractionSystemPrompt:
or "saving" in prompt.lower()
or "remember" in prompt.lower()
)
-
-
-class TestConversationExtractionPromptBasic:
- """Tests for CONVERSATION_EXTRACTION_PROMPT_BASIC preset."""
-
- def test_prompt_is_non_empty_string(self):
- """Preset prompt should be a non-empty string."""
- assert isinstance(CONVERSATION_EXTRACTION_PROMPT_BASIC, str)
- assert len(CONVERSATION_EXTRACTION_PROMPT_BASIC) > 0
-
- def test_prompt_is_generated_without_arguments(self):
- """Preset should match calling generator with no args."""
- expected = get_conversation_extraction_prompt()
- assert CONVERSATION_EXTRACTION_PROMPT_BASIC == expected
-
-
-# =============================================================================
-# Test get_conversation_extraction_prompt()
-# =============================================================================
-
-
-class TestGetConversationExtractionPrompt:
- """Tests for get_conversation_extraction_prompt() function."""
-
- def test_returns_string(self):
- """Function should return a string."""
- result = get_conversation_extraction_prompt()
- assert isinstance(result, str)
-
- def test_returns_non_empty_prompt(self):
- """Function should return non-empty prompt."""
- result = get_conversation_extraction_prompt()
- assert len(result) > 100 # Should be substantial
-
- def test_no_args_excludes_speaker_section(self):
- """Without speaker_names, should not include SPEAKERS section."""
- result = get_conversation_extraction_prompt()
- assert "SPEAKERS:" not in result
-
- def test_no_args_excludes_temporal_section(self):
- """Without context_date, should not include TEMPORAL CONTEXT."""
- result = get_conversation_extraction_prompt()
- assert "TEMPORAL CONTEXT:" not in result
-
- def test_single_speaker_included(self):
- """Single speaker name should appear in prompt."""
- result = get_conversation_extraction_prompt(speaker_names=["Alice"])
-
- assert "SPEAKERS: Alice" in result
- assert "Alice" in result # Should appear in examples too
-
- def test_multiple_speakers_included(self):
- """Multiple speaker names should be comma-separated."""
- result = get_conversation_extraction_prompt(speaker_names=["Alice", "Bob", "Charlie"])
-
- assert "SPEAKERS: Alice, Bob, Charlie" in result
-
- def test_first_speaker_used_in_examples(self):
- """First speaker should be used in example snippets."""
- result = get_conversation_extraction_prompt(speaker_names=["Tanay", "Bob"])
-
- # First speaker should replace default "Alice" in examples
- assert "Tanay" in result
- # Check specific example patterns
- assert "Tanay" in result
-
- def test_context_date_creates_temporal_section(self):
- """Context date should create TEMPORAL CONTEXT section."""
- result = get_conversation_extraction_prompt(context_date="May 7, 2023")
-
- assert "TEMPORAL CONTEXT:" in result
- assert "May 7, 2023" in result
-
- def test_temporal_section_explains_conversions(self):
- """Temporal section should explain date conversions."""
- result = get_conversation_extraction_prompt(context_date="January 15, 2024")
-
- assert "last year" in result.lower()
- assert "yesterday" in result.lower()
- assert "last week" in result.lower()
- assert "next month" in result.lower()
-
- def test_both_speaker_and_date_included(self):
- """Both speaker names and date should work together."""
- result = get_conversation_extraction_prompt(
- speaker_names=["Eve", "Frank"], context_date="December 1, 2023"
- )
-
- assert "SPEAKERS: Eve, Frank" in result
- assert "TEMPORAL CONTEXT:" in result
- assert "December 1, 2023" in result
- assert "Eve" in result # Used in examples
-
- def test_contains_extraction_categories(self):
- """Prompt should list what to extract."""
- result = get_conversation_extraction_prompt()
-
- assert "IDENTITY" in result or "CHARACTERISTICS" in result
- assert "PREFERENCES" in result
- assert "ACTIVITIES" in result
- assert "RELATIONSHIPS" in result
- assert "EVENTS" in result
- assert "PLANS" in result or "GOALS" in result
-
- def test_contains_importance_scoring_guidance(self):
- """Prompt should explain importance scoring."""
- result = get_conversation_extraction_prompt()
-
- assert "importance" in result.lower()
- assert "0.3" in result or "0.4" in result # Background
- assert "0.5" in result or "0.6" in result # Useful
- assert "0.7" in result or "0.8" in result # Important
- assert "0.9" in result or "1.0" in result # Critical
-
- def test_contains_atomic_fact_format(self):
- """Prompt should explain atomic fact format."""
- result = get_conversation_extraction_prompt()
-
- assert "ATOMIC FACT" in result or "atomic fact" in result.lower()
- assert "GOOD:" in result or "✓ GOOD" in result
- assert "BAD:" in result or "✗ BAD" in result
-
- def test_contains_few_shot_examples(self):
- """Prompt should contain few-shot examples."""
- result = get_conversation_extraction_prompt()
-
- assert "FEW-SHOT EXAMPLES" in result or "Examples:" in result
- assert "Input:" in result
- assert "Output:" in result
-
- def test_contains_filtering_guidance(self):
- """Prompt should explain what NOT to extract."""
- result = get_conversation_extraction_prompt()
-
- assert "FILTERING" in result or "DO NOT extract" in result
- assert "greetings" in result.lower()
- assert "transient" in result.lower()
- assert "sensitive" in result.lower()
-
- def test_empty_speaker_list_treated_as_none(self):
- """Empty speaker list should not add SPEAKERS section."""
- result = get_conversation_extraction_prompt(speaker_names=[])
- assert "SPEAKERS:" not in result
-
- def test_special_characters_in_speaker_names(self):
- """Speaker names with special characters should work."""
- result = get_conversation_extraction_prompt(speaker_names=["O'Brien", "Jean-Luc"])
-
- assert "O'Brien" in result
- assert "Jean-Luc" in result
-
- def test_very_long_speaker_list(self):
- """Long speaker lists should be handled."""
- speakers = [f"Person{i}" for i in range(10)]
- result = get_conversation_extraction_prompt(speaker_names=speakers)
-
- assert "Person0" in result
- assert "Person9" in result
- # All speakers should be comma-separated
- assert "SPEAKERS: " in result
-
-
-# =============================================================================
-# Test get_memory_answer_prompt()
-# =============================================================================
-
-
-class TestGetMemoryAnswerPrompt:
- """Tests for get_memory_answer_prompt() function."""
-
- def test_returns_string(self):
- """Function should return a string."""
- result = get_memory_answer_prompt()
- assert isinstance(result, str)
-
- def test_returns_non_empty_prompt(self):
- """Function should return non-empty prompt."""
- result = get_memory_answer_prompt()
- assert len(result) > 50
-
- def test_no_args_generic_context(self):
- """Without speaker_names, context should be generic."""
- result = get_memory_answer_prompt()
-
- # Should mention memory system
- assert "memory" in result.lower()
- # The first line should be "You are answering questions using a memory system."
- # (no "about X" context added)
- first_line = result.split("\n")[0]
- assert "about" not in first_line
-
- def test_single_speaker_adds_context(self):
- """Single speaker should add context about them."""
- result = get_memory_answer_prompt(speaker_names=["Alice"])
-
- assert "about Alice" in result
-
- def test_multiple_speakers_joined_with_and(self):
- """Multiple speakers should be joined with 'and'."""
- result = get_memory_answer_prompt(speaker_names=["Alice", "Bob"])
-
- assert "about Alice and Bob" in result
-
- def test_three_speakers_joined_correctly(self):
- """Three speakers use ' and ' between all."""
- result = get_memory_answer_prompt(speaker_names=["Alice", "Bob", "Charlie"])
-
- # Should join with ' and ' for all names
- assert "Alice and Bob and Charlie" in result
-
- def test_contains_process_steps(self):
- """Prompt should explain the answer process."""
- result = get_memory_answer_prompt()
-
- assert "PROCESS" in result or "Process" in result
- assert "memory_search" in result
-
- def test_contains_answer_rules(self):
- """Prompt should contain answer rules."""
- result = get_memory_answer_prompt()
-
- assert "ANSWER RULES" in result or "rules" in result.lower()
- assert "CONCISE" in result or "concise" in result.lower()
-
- def test_handles_inference_questions(self):
- """Prompt should explain how to handle inference questions."""
- result = get_memory_answer_prompt()
-
- assert "INFERENCE" in result or "inference" in result.lower()
- assert "would" in result.lower() or "could" in result.lower()
-
- def test_handles_not_found_case(self):
- """Prompt should explain what to do when info not found."""
- result = get_memory_answer_prompt()
-
- assert "not found" in result.lower() or "Information not found" in result
-
- def test_empty_speaker_list_treated_as_none(self):
- """Empty speaker list should be treated as None."""
- result = get_memory_answer_prompt(speaker_names=[])
-
- # Empty list should result in no " about X" context
- # The function joins empty list which results in empty string
- # So "about " would be followed by nothing meaningful
- # Both should be similar (no specific speaker context)
- assert "about " not in result # No double space
-
-
-# =============================================================================
-# Test MEMORY_SAVE_TOOL_WITH_EXTRACTION
-# =============================================================================
-
-
-class TestMemorySaveToolWithExtraction:
- """Tests for MEMORY_SAVE_TOOL_WITH_EXTRACTION schema."""
-
- def test_is_dict(self):
- """Tool schema should be a dictionary."""
- assert isinstance(MEMORY_SAVE_TOOL_WITH_EXTRACTION, dict)
-
- def test_has_type_field(self):
- """Tool should have type field set to 'function'."""
- assert MEMORY_SAVE_TOOL_WITH_EXTRACTION.get("type") == "function"
-
- def test_has_function_field(self):
- """Tool should have function field."""
- assert "function" in MEMORY_SAVE_TOOL_WITH_EXTRACTION
- assert isinstance(MEMORY_SAVE_TOOL_WITH_EXTRACTION["function"], dict)
-
- def test_function_has_name(self):
- """Function should have name 'memory_save'."""
- func = MEMORY_SAVE_TOOL_WITH_EXTRACTION["function"]
- assert func.get("name") == "memory_save"
-
- def test_function_has_description(self):
- """Function should have non-empty description."""
- func = MEMORY_SAVE_TOOL_WITH_EXTRACTION["function"]
-
- assert "description" in func
- assert isinstance(func["description"], str)
- assert len(func["description"]) > 50
-
- def test_description_mentions_extraction(self):
- """Description should mention pre-extraction."""
- func = MEMORY_SAVE_TOOL_WITH_EXTRACTION["function"]
- desc = func["description"]
-
- assert "extract" in desc.lower()
- assert "facts" in desc.lower()
- assert "entities" in desc.lower()
- assert "relationships" in desc.lower()
-
- def test_has_parameters_field(self):
- """Function should have parameters field."""
- func = MEMORY_SAVE_TOOL_WITH_EXTRACTION["function"]
-
- assert "parameters" in func
- assert isinstance(func["parameters"], dict)
-
- def test_parameters_has_type_object(self):
- """Parameters should be type object."""
- params = MEMORY_SAVE_TOOL_WITH_EXTRACTION["function"]["parameters"]
-
- assert params.get("type") == "object"
-
- def test_parameters_has_properties(self):
- """Parameters should have properties field."""
- params = MEMORY_SAVE_TOOL_WITH_EXTRACTION["function"]["parameters"]
-
- assert "properties" in params
- assert isinstance(params["properties"], dict)
-
- def test_content_parameter_exists(self):
- """Should have content parameter."""
- props = MEMORY_SAVE_TOOL_WITH_EXTRACTION["function"]["parameters"]["properties"]
-
- assert "content" in props
- assert props["content"].get("type") == "string"
-
- def test_importance_parameter_exists(self):
- """Should have importance parameter with range."""
- props = MEMORY_SAVE_TOOL_WITH_EXTRACTION["function"]["parameters"]["properties"]
-
- assert "importance" in props
- importance = props["importance"]
-
- assert importance.get("type") == "number"
- assert importance.get("minimum") == 0.0
- assert importance.get("maximum") == 1.0
-
- def test_facts_parameter_exists(self):
- """Should have facts parameter as array of strings."""
- props = MEMORY_SAVE_TOOL_WITH_EXTRACTION["function"]["parameters"]["properties"]
-
- assert "facts" in props
- facts = props["facts"]
-
- assert facts.get("type") == "array"
- assert facts.get("items", {}).get("type") == "string"
-
- def test_extracted_entities_parameter_exists(self):
- """Should have extracted_entities parameter with proper schema."""
- props = MEMORY_SAVE_TOOL_WITH_EXTRACTION["function"]["parameters"]["properties"]
-
- assert "extracted_entities" in props
- entities = props["extracted_entities"]
-
- assert entities.get("type") == "array"
-
- # Check items schema
- items = entities.get("items", {})
- assert items.get("type") == "object"
-
- item_props = items.get("properties", {})
- assert "entity" in item_props
- assert "entity_type" in item_props
-
- required = items.get("required", [])
- assert "entity" in required
- assert "entity_type" in required
-
- def test_extracted_relationships_parameter_exists(self):
- """Should have extracted_relationships parameter with proper schema."""
- props = MEMORY_SAVE_TOOL_WITH_EXTRACTION["function"]["parameters"]["properties"]
-
- assert "extracted_relationships" in props
- rels = props["extracted_relationships"]
-
- assert rels.get("type") == "array"
-
- # Check items schema
- items = rels.get("items", {})
- assert items.get("type") == "object"
-
- item_props = items.get("properties", {})
- assert "source" in item_props
- assert "relationship" in item_props
- assert "destination" in item_props
-
- required = items.get("required", [])
- assert "source" in required
- assert "relationship" in required
- assert "destination" in required
-
- def test_required_fields(self):
- """Content and importance should be required."""
- params = MEMORY_SAVE_TOOL_WITH_EXTRACTION["function"]["parameters"]
-
- assert "required" in params
- required = params["required"]
-
- assert "content" in required
- assert "importance" in required
-
-
-# =============================================================================
-# Test get_extraction_tools()
-# =============================================================================
-
-
-class TestGetExtractionTools:
- """Tests for get_extraction_tools() function."""
-
- def test_returns_list(self):
- """Function should return a list."""
- result = get_extraction_tools()
- assert isinstance(result, list)
-
- def test_returns_three_tools(self):
- """Should return exactly 3 extraction tools."""
- result = get_extraction_tools()
- assert len(result) == 3
-
- def test_all_items_are_dicts(self):
- """All items should be dictionaries."""
- result = get_extraction_tools()
- for tool in result:
- assert isinstance(tool, dict)
-
- def test_all_tools_have_function_type(self):
- """All tools should have type 'function'."""
- result = get_extraction_tools()
- for tool in result:
- assert tool.get("type") == "function"
-
- def test_all_tools_have_function_field(self):
- """All tools should have function field."""
- result = get_extraction_tools()
- for tool in result:
- assert "function" in tool
- assert isinstance(tool["function"], dict)
-
- def test_extract_facts_tool_exists(self):
- """Should have extract_facts tool."""
- result = get_extraction_tools()
- tool_names = [t["function"]["name"] for t in result]
-
- assert "extract_facts" in tool_names
-
- def test_extract_entities_tool_exists(self):
- """Should have extract_entities tool."""
- result = get_extraction_tools()
- tool_names = [t["function"]["name"] for t in result]
-
- assert "extract_entities" in tool_names
-
- def test_extract_relationships_tool_exists(self):
- """Should have extract_relationships tool."""
- result = get_extraction_tools()
- tool_names = [t["function"]["name"] for t in result]
-
- assert "extract_relationships" in tool_names
-
- def test_extract_facts_schema(self):
- """extract_facts should have correct schema."""
- result = get_extraction_tools()
- facts_tool = next(t for t in result if t["function"]["name"] == "extract_facts")
-
- func = facts_tool["function"]
- assert "description" in func
- assert "parameters" in func
-
- params = func["parameters"]
- assert params.get("type") == "object"
- assert "facts" in params.get("properties", {})
-
- facts_prop = params["properties"]["facts"]
- assert facts_prop.get("type") == "array"
- assert facts_prop.get("items", {}).get("type") == "string"
-
- assert "facts" in params.get("required", [])
-
- def test_extract_entities_schema(self):
- """extract_entities should have correct schema."""
- result = get_extraction_tools()
- entities_tool = next(t for t in result if t["function"]["name"] == "extract_entities")
-
- func = entities_tool["function"]
- assert "description" in func
- assert "parameters" in func
-
- params = func["parameters"]
- assert params.get("type") == "object"
- assert "entities" in params.get("properties", {})
-
- entities_prop = params["properties"]["entities"]
- assert entities_prop.get("type") == "array"
-
- items = entities_prop.get("items", {})
- assert items.get("type") == "object"
- assert "entity" in items.get("properties", {})
- assert "entity_type" in items.get("properties", {})
-
- assert "entities" in params.get("required", [])
-
- def test_extract_relationships_schema(self):
- """extract_relationships should have correct schema."""
- result = get_extraction_tools()
- rels_tool = next(t for t in result if t["function"]["name"] == "extract_relationships")
-
- func = rels_tool["function"]
- assert "description" in func
- assert "parameters" in func
-
- params = func["parameters"]
- assert params.get("type") == "object"
- assert "relationships" in params.get("properties", {})
-
- rels_prop = params["properties"]["relationships"]
- assert rels_prop.get("type") == "array"
-
- items = rels_prop.get("items", {})
- assert items.get("type") == "object"
- item_props = items.get("properties", {})
- assert "source" in item_props
- assert "relationship" in item_props
- assert "destination" in item_props
-
- assert "relationships" in params.get("required", [])
-
- def test_returns_new_list_each_call(self):
- """Should return a new list each call (not same reference)."""
- result1 = get_extraction_tools()
- result2 = get_extraction_tools()
-
- assert result1 is not result2
- # But content should be equal
- assert result1 == result2
-
-
-# =============================================================================
-# Integration Tests
-# =============================================================================
-
-
-class TestExtractionIntegration:
- """Integration tests for extraction module."""
-
- def test_prompts_are_different(self):
- """Each prompt constant should be unique."""
- prompts = [
- FACT_EXTRACTION_PROMPT,
- ENTITY_EXTRACTION_PROMPT,
- RELATIONSHIP_EXTRACTION_PROMPT,
- EXTRACTION_SYSTEM_PROMPT,
- ]
-
- # All prompts should be different
- for i, p1 in enumerate(prompts):
- for j, p2 in enumerate(prompts):
- if i != j:
- assert p1 != p2
-
- def test_conversation_prompt_changes_with_speaker(self):
- """Conversation prompt should change based on speaker."""
- prompt_default = get_conversation_extraction_prompt()
- prompt_alice = get_conversation_extraction_prompt(speaker_names=["Alice"])
- prompt_bob = get_conversation_extraction_prompt(speaker_names=["Bob"])
-
- assert prompt_default != prompt_alice
- assert prompt_alice != prompt_bob
-
- def test_conversation_prompt_changes_with_date(self):
- """Conversation prompt should change based on date."""
- prompt_no_date = get_conversation_extraction_prompt()
- prompt_date1 = get_conversation_extraction_prompt(context_date="January 1, 2024")
- prompt_date2 = get_conversation_extraction_prompt(context_date="December 31, 2024")
-
- assert prompt_no_date != prompt_date1
- assert prompt_date1 != prompt_date2
-
- def test_answer_prompt_changes_with_speaker(self):
- """Answer prompt should change based on speaker."""
- prompt_default = get_memory_answer_prompt()
- prompt_alice = get_memory_answer_prompt(speaker_names=["Alice"])
-
- assert prompt_default != prompt_alice
-
- def test_tool_schema_is_valid_json_serializable(self):
- """Tool schema should be JSON serializable."""
- import json
-
- # Should not raise
- json_str = json.dumps(MEMORY_SAVE_TOOL_WITH_EXTRACTION)
- # Should round-trip correctly
- loaded = json.loads(json_str)
- assert loaded == MEMORY_SAVE_TOOL_WITH_EXTRACTION
-
- def test_extraction_tools_are_json_serializable(self):
- """Extraction tools should be JSON serializable."""
- import json
-
- tools = get_extraction_tools()
-
- # Should not raise
- json_str = json.dumps(tools)
- # Should round-trip correctly
- loaded = json.loads(json_str)
- assert loaded == tools
-
- def test_all_tool_names_unique(self):
- """All tool names should be unique."""
- tools = get_extraction_tools()
- names = [t["function"]["name"] for t in tools]
-
- assert len(names) == len(set(names))
-
- def test_memory_save_tool_compatible_with_extraction_tools(self):
- """Memory save tool should accept outputs from extraction tools."""
- # The memory_save tool accepts:
- # - facts: array of strings (from extract_facts)
- # - extracted_entities: array of {entity, entity_type} (from extract_entities)
- # - extracted_relationships: array of {source, relationship, destination} (from extract_relationships)
-
- save_tool = MEMORY_SAVE_TOOL_WITH_EXTRACTION["function"]["parameters"]["properties"]
- extraction_tools = {t["function"]["name"]: t for t in get_extraction_tools()}
-
- # Facts compatibility
- facts_output = extraction_tools["extract_facts"]["function"]["parameters"]["properties"][
- "facts"
- ]
- save_facts_input = save_tool["facts"]
- assert facts_output["type"] == save_facts_input["type"] # both array
- assert facts_output["items"]["type"] == save_facts_input["items"]["type"] # both string
-
- # Entities compatibility
- entities_output = extraction_tools["extract_entities"]["function"]["parameters"][
- "properties"
- ]["entities"]
- save_entities_input = save_tool["extracted_entities"]
- assert entities_output["type"] == save_entities_input["type"] # both array
- # Both have object items with entity and entity_type
- assert entities_output["items"]["type"] == save_entities_input["items"]["type"]
-
- # Relationships compatibility
- rels_output = extraction_tools["extract_relationships"]["function"]["parameters"][
- "properties"
- ]["relationships"]
- save_rels_input = save_tool["extracted_relationships"]
- assert rels_output["type"] == save_rels_input["type"] # both array
- # Both have object items with source, relationship, destination
- assert rels_output["items"]["type"] == save_rels_input["items"]["type"]
diff --git a/tests/test_memory_integration.py b/tests/test_memory_integration.py
index a80f58df5..afb67b580 100644
--- a/tests/test_memory_integration.py
+++ b/tests/test_memory_integration.py
@@ -565,23 +565,13 @@ class TestMemoryIntegration:
class TestExtractionPrompts:
- """Tests for extraction prompt templates."""
+ """Tests for the extraction prompt template."""
def test_extraction_prompts_exist_and_valid(self):
- """Verify extraction prompts are defined and non-empty."""
- from headroom.memory.extraction import (
- ENTITY_EXTRACTION_PROMPT,
- EXTRACTION_SYSTEM_PROMPT,
- FACT_EXTRACTION_PROMPT,
- RELATIONSHIP_EXTRACTION_PROMPT,
- )
+ """Verify the extraction system prompt is defined and non-empty."""
+ from headroom.memory.extraction import EXTRACTION_SYSTEM_PROMPT
assert len(EXTRACTION_SYSTEM_PROMPT) > 100, "System prompt should be substantial"
- assert len(FACT_EXTRACTION_PROMPT) > 100, "Fact prompt should be substantial"
- assert len(ENTITY_EXTRACTION_PROMPT) > 100, "Entity prompt should be substantial"
- assert len(RELATIONSHIP_EXTRACTION_PROMPT) > 100, (
- "Relationship prompt should be substantial"
- )
# Verify they mention key concepts
assert "facts" in EXTRACTION_SYSTEM_PROMPT.lower()