Edistyneet muistiratkaisut

from langchain.memory import ConversationSummaryBufferMemory
from langchain_openai import OpenAI

# For demonstration, we'll use a mock LLM
# In a real scenario, you'd use your actual LLM (e.g., OpenAI, HuggingFace)
# from langchain.llms import OpenAI
# llm = OpenAI(temperature=0)

class MockLLM:
    def __init__(self):
        pass
    def invoke(self, prompt):
        if "summarize" in prompt.lower():
            return "A short summary of the conversation."
        return "Mock LLM response to: " + prompt

llm = MockLLM()

# max_token_limit ensures summary happens before context window is full
memory = ConversationSummaryBufferMemory(llm=llm, max_token_limit=100)

def run_interaction(user_input, ai_output):
    memory.save_context({"input": user_input}, {"output": ai_output})
    print(f"Memory buffer: {memory.load_memory_variables({})['history']}")

if __name__ == "__main__":
    print("--- Summary Buffer Memory Demo ---")
    run_interaction("Hi there!", "Hello! How can I help?")
    run_interaction("My name is Alice.", "Nice to meet you, Alice.")
    run_interaction("I want to discuss project Alpha.", "Okay, tell me more.")
    run_interaction("Project Alpha is about AI agents.", "Interesting! What aspects?")
    # After more interactions, older messages would be summarized
    print("\nFinal memory (after potential summarization):")
    print(memory.load_memory_variables({})['history'])

from langchain.memory import ConversationEntityMemory
from langchain_openai import OpenAI

# Using the same MockLLM for consistency
class MockLLM:
    def __init__(self):
        pass
    def invoke(self, prompt):
        if "extract entities" in prompt.lower():
            if "Alice" in prompt:
                return "{'Alice': 'Alice is a person. She likes coffee and project Alpha.'}"
            return "{}"
        if "summarize" in prompt.lower():
            return "A short summary of the conversation."
        return "Mock LLM response to: " + prompt

llm = MockLLM()

memory = ConversationEntityMemory(llm=llm)

def run_entity_interaction(user_input, ai_output):
    memory.save_context({"input": user_input}, {"output": ai_output})
    print(f"Entities: {memory.load_memory_variables({})['entities']}")

if __name__ == "__main__":
    print("--- Entity Memory Demo ---")
    run_entity_interaction("My name is Alice and I like coffee.", "Nice to meet you, Alice!")
    run_entity_interaction("I am working on project Alpha.", "That sounds interesting.")
    run_entity_interaction("My colleague Bob will join later.", "Okay, I'll remember Bob.")

    print("\nFinal entities stored:")
    print(memory.load_memory_variables({})['entities'])

import json
from langchain.memory import ConversationBufferMemory

# Example of a simple buffer memory
memory = ConversationBufferMemory()

if __name__ == "__main__":
    print("--- Memory Persistence Demo ---")

    # 1. Save context
    memory.save_context({"input": "Hello!"}, {"output": "Hi there!"})
    memory.save_context({"input": "How are you?"}, {"output": "I'm good!"})

    # 2. Extract and save memory variables
    memory_data = memory.load_memory_variables({})
    print(f"Memory before saving: {memory_data}")

    # Convert to JSON string and save to a file
    with open("agent_memory.json", "w") as f:
        json.dump(memory_data, f, indent=2)
    print("\nMemory saved to agent_memory.json")

    # 3. Create new memory and load from file
    new_memory = ConversationBufferMemory()
    with open("agent_memory.json", "r") as f:
        loaded_data = json.load(f)

    # For ConversationBufferMemory, you can set the buffer directly
    # More complex memories might have specific load methods
    new_memory.buffer = loaded_data.get('history', '')
    print(f"\nMemory loaded into new agent: {new_memory.load_memory_variables({})['history']}")