Merge pull request #104 from Dooders/dev

Dev

Author: csmangum

memory/search/strategies/sequence.py

@@ -115,6 +115,25 @@ def search(
         # Get all memories for filtering
         all_memories = store.get_all(agent_id)
 
+        # Get reference memory type from content metadata
+        reference_type = None
+        if isinstance(reference_memory.get("content"), dict):
+            reference_type = reference_memory.get("content", {}).get("metadata", {}).get("type")
+        else:
+            # If content is a string, check metadata directly
+            reference_type = reference_memory.get("metadata", {}).get("type")
+
+        # Filter memories by type if reference type exists
+        if reference_type:
+            all_memories = [
+                memory
+                for memory in all_memories
+                if (isinstance(memory.get("content"), dict) and 
+                    memory.get("content", {}).get("metadata", {}).get("type") == reference_type) or
+                   (not isinstance(memory.get("content"), dict) and 
+                    memory.get("metadata", {}).get("type") == reference_type)
+            ]
+
         # Sort memories by timestamp
         sorted_memories = self._sort_memories_by_timestamp(
             all_memories, timestamp_field
@@ -146,24 +165,36 @@ def search(
 
             # Convert timestamp to datetime
             if isinstance(reference_timestamp, str):
-                reference_dt = datetime.fromisoformat(reference_timestamp)
+                try:
+                    reference_dt = datetime.fromisoformat(reference_timestamp)
+                except ValueError:
+                    reference_dt = datetime.fromtimestamp(float(reference_timestamp))
             else:
                 reference_dt = datetime.fromtimestamp(float(reference_timestamp))
-            window_start = reference_dt - timedelta(minutes=time_window_minutes)
-            window_end = reference_dt + timedelta(minutes=time_window_minutes)
+            
+            # Convert window to seconds for Unix timestamp comparison
+            window_seconds = time_window_minutes * 60
+            window_start_ts = reference_dt.timestamp() - window_seconds
+            window_end_ts = reference_dt.timestamp() + window_seconds
 
             results = []
             for memory in sorted_memories:
                 memory_timestamp = self._get_timestamp_value(memory, timestamp_field)
                 if memory_timestamp is None:
                     continue
 
-                # Convert memory timestamp to datetime
+                # Convert memory timestamp to float for comparison
                 if isinstance(memory_timestamp, str):
-                    memory_dt = datetime.fromisoformat(memory_timestamp)
+                    try:
+                        memory_dt = datetime.fromisoformat(memory_timestamp)
+                        memory_ts = memory_dt.timestamp()
+                    except ValueError:
+                        memory_ts = float(memory_timestamp)
                 else:
-                    memory_dt = datetime.fromtimestamp(float(memory_timestamp))
-                if window_start <= memory_dt <= window_end:
+                    memory_ts = float(memory_timestamp)
+                
+                # Compare timestamps
+                if window_start_ts <= memory_ts <= window_end_ts:
                     # Mark the reference memory
                     memory_id = memory.get("memory_id") or memory.get("id")
                     if memory_id == reference_id:
@@ -277,3 +308,15 @@ def _matches_metadata_filter(self, memory, metadata_filter):
                 return False
 
         return True
+
+    def _extract_memory_id(self, memory: Dict[str, Any]) -> str:
+        """
+        Extract memory ID from a memory object.
+
+        Args:
+            memory: Memory object to extract ID from
+
+        Returns:
+            Memory ID as string
+        """
+        return memory.get("memory_id") or memory.get("id")

requirements.txt

@@ -30,6 +30,8 @@ matplotlib
 numpy
 tiktoken
 openai
+openai-agents
+openai-voice
 
 # Additional needed dependencies
 redis[hiredis]

scripts/agent_conversation.py

@@ -0,0 +1,111 @@
+import os
+from agents import Agent, Runner
+import asyncio
+from dotenv import load_dotenv
+import time
+from openai import OpenAI
+import tempfile
+import sounddevice as sd
+import soundfile as sf
+# Load environment variables
+load_dotenv()
+
+# Initialize OpenAI client
+client = OpenAI()
+
+# Ensure OpenAI API key is set
+if not os.getenv("OPENAI_API_KEY"):
+    raise ValueError("Please set OPENAI_API_KEY environment variable")
+
+# Create two agents with different roles
+lincoln = Agent(
+    name="Abraham Lincoln",
+    instructions="""You are Abraham Lincoln, speaking privately with Nero.""",
+    model="gpt-3.5-turbo"
+)
+
+nero = Agent(
+    name="Emperor Nero",
+    instructions="""You are Emperor Nero, speaking privately with Abraham Lincoln.""",
+    model="gpt-3.5-turbo"
+)
+
+async def text_to_speech(text, voice="alloy"):
+    """Convert text to speech using OpenAI's TTS API"""
+    try:
+        response = client.audio.speech.create(
+            model="tts-1",
+            voice=voice,
+            input=text
+        )
+        
+        # Save to temporary file
+        with tempfile.NamedTemporaryFile(delete=False, suffix='.mp3') as temp_file:
+            temp_file.write(response.content)
+            temp_file_path = temp_file.name
+        
+        # Play the audio
+        data, samplerate = sf.read(temp_file_path)
+        sd.play(data, samplerate)
+        sd.wait()  # Wait until audio is finished playing
+        
+        # Clean up
+        os.unlink(temp_file_path)
+        
+    except Exception as e:
+        print(f"Error in text-to-speech: {str(e)}")
+
+async def run_conversation():
+    # Initial message to start the conversation
+    initial_message = "You know, Nero, I've been thinking... The weight of leadership, it changes a man. I lost my son Willie last year, and sometimes I wonder if the price of this office is too high. Do you ever feel that way? That the crown, or in my case, the presidency, comes at a cost to your soul?"
+    
+    # Set up the conversation loop
+    current_message = initial_message
+    turn_count = 0
+    max_turns = 2  # Reduced number of turns for faster execution
+    max_retries = 2  # Reduced retries
+    
+    print("\n=== A Private Conversation Between Leaders ===\n")
+    print("Lincoln and Nero share a moment of quiet reflection.")
+    print("Press Ctrl+C at any time to end the conversation.\n")
+    
+    # Speak the initial message
+    await text_to_speech(initial_message, voice="alloy")
+    
+    while turn_count < max_turns * 2:  # Each agent gets max_turns
+        # Determine which agent's turn it is
+        current_agent = lincoln if turn_count % 2 == 0 else nero
+        
+        # Get the agent's response with retry logic
+        for attempt in range(max_retries):
+            try:
+                result = await Runner.run(current_agent, current_message)
+                response = result.final_output
+                break
+            except Exception as e:
+                if attempt == max_retries - 1:  # Last attempt
+                    print(f"\nError: Failed to get response after {max_retries} attempts.")
+                    print(f"Error details: {str(e)}")
+                    return
+                print(f"\nAttempt {attempt + 1} failed, retrying in 1 second...")
+                await asyncio.sleep(1)  # Reduced sleep time
+        
+        # Print and speak the response
+        print(f"\n{current_agent.name}: {response}\n")
+        print("-" * 50)
+        
+        # Speak the response with different voices for each agent
+        await text_to_speech(response, voice="alloy" if current_agent.name == "Abraham Lincoln" else "echo")
+        
+        # Update the message for the next turn
+        current_message = response
+        turn_count += 1
+
+if __name__ == "__main__":
+    try:
+        # Run the conversation
+        asyncio.run(run_conversation())
+    except KeyboardInterrupt:
+        print("\n\nConversation interrupted by user.")
+    except Exception as e:
+        print(f"\nAn unexpected error occurred: {str(e)}") 

validation/search/sequence/sequence_test_suite.py

@@ -111,7 +111,7 @@ def run_advanced_tests(self) -> None:
             "Time Window Sequence",
             {
                 "reference_id": "test-agent-sequence-search-meeting-123456-3",
-                "time_window_minutes": 30,
+                "time_window_minutes": 1440,  # 24 hours
             },
             expected_memory_ids=[
                 "test-agent-sequence-search-meeting-123456-2",
@@ -127,6 +127,7 @@ def run_advanced_tests(self) -> None:
             {
                 "reference_id": "test-agent-sequence-search-meeting-123456-3",
                 "tier": "stm",
+                "sequence_size": 3,
             },
             expected_memory_ids=[
                 "test-agent-sequence-search-meeting-123456-2",