from agents import Agent, Runner, function_tool  

# 你的文檔（生產(chǎn)環(huán)境中，使用合適的 vector database）  
documents = [  
    {  
        "title": "Apollo 11 Mission",   
        "content": "Apollo 11 was the first spaceflight to land humans on the Moon. It launched in 1969."  
    },  
    {  
        "title": "Neil Armstrong Bio",   
        "content": "Neil Armstrong was the first person to walk on the Moon, during the Apollo 11 mission."  
    }  
]  

# 你的代理的記憶筆記本  
memory_store = []

@function_tool  
def retrieve_docs(query: str) -> str:  
    """Search documents for relevant information."""  
    for doc in documents:  
        if query.lower() in doc["content"].lower():  
            return f"From {doc['title']}: {doc['content']}"  
    return "No relevant document found."  

@function_tool  
def summarize_content(text: str) -> str:  
    """Create a concise summary of the text."""  
    if len(text.split()) < 30:  
        return text  
    # In production, use an LLM call here  
    summary = text.split('.')[0] + '.'  
    return f"SUMMARY: {summary}"  

@function_tool  
def store_summary(info: str) -> str:  
    """Save important information to long-term memory."""  
    memory_store.append(info)  
    return "Stored in memory."  

@function_tool  
def search_memory(query: str) -> str:  
    """Search through stored memories."""  
    for entry in memory_store:  
        if query.lower() in entry.lower():  
            return entry  
    return ""

memory_rag_agent = Agent(  
    name="SmartResearchAssistant",  
    model="gpt-4",  
    instructinotallow="""  
You are an AI research assistant with a perfect memory system.  

Here's your workflow:  
1. **Always check memory first** - Use search_memory() to see if you already   
know the answer  
2. **Retrieve new info only when needed** - If memory doesn't help, use   
retrieve_docs()  
3. **Summarize and store** - Use summarize_content() then store_summary()   
for new findings  
4. **Build your knowledge base** - Over time, you'll become an expert on   
the topics  

Remember: Your memory is your superpower. Use it wisely and never forget to update it with new knowledge!  
""",  
    tools=[search_memory, retrieve_docs, summarize_content, store_summary]  
)

user_query1 = "Who was the first person to walk on the Moon?"  
result1 = Runner.run_sync(memory_rag_agent, user_query1)

user_query2 = "What mission was that?"  
result2 = Runner.run_sync(memory_rag_agent, user_query2)

memory_structure = {  
    "facts": [],           # 快速事實查找  
    "procedures": [],      # 一步一步的過程  
    "relationships": [],   # 概念之間的連接  
    "summaries": []        # 高層概述  
}

@function_tool  
def store_memory_with_priority(info: str, priority: str = "medium") -> str:  
    """Store memory with importance level."""  
    timestamp = datetime.now()  
    memory_entry = {  
        "content": info,  
        "priority": priority,  
        "timestamp": timestamp,  
        "access_count": 0  
    }  
    memory_store.append(memory_entry)  
    return f"Stored {priority} priority memory."

@function_tool  
def semantic_memory_search(query: str) -> str:  
    """Find memories using semantic similarity."""  
    query_embedding = get_embedding(query)  
      
    best_match = None  
    best_score = 0  
      
    for memory in memory_store:  
        memory_embedding = memory.get("embedding")  
        if memory_embedding:  
            similarity = cosine_similarity(query_embedding, memory_embedding)  
            if similarity > best_score and similarity > 0.8:  
                best_score = similarity  
                best_match = memory["content"]  
      
    return best_match or ""

@function_tool  
def should_store_memory(text: str, context: str) -> bool:  
    """Decide if information is worth remembering."""  
    if len(text.split()) < 5:  # 太短  
        return False  
    if "trivial" in context.lower():  # 明確標(biāo)記為不重要  
        return False  
    return True

@function_tool  
def refresh_memory(topic: str) -> str:  
    """Update memories about a specific topic."""  
    # Remove old memories about topic  
    global memory_store  
    memory_store = [m for m in memory_store if topic.lower() not in m.lower()]  
      
    # Retrieve fresh information  
    fresh_info = retrieve_docs(topic)  
    if fresh_info:  
        summary = summarize_content(fresh_info)  
        store_summary(f"[UPDATED] {summary}")  
      
    return f"Refreshed memory about {topic}"

@function_tool  
def store_tagged_memory(info: str, tags: list) -> str:  
    """Store memory with searchable tags."""  
    memory_entry = {  
        "content": info,  
        "tags": tags,  
        "timestamp": datetime.now()  
    }  
    memory_store.append(memory_entry)  
    return f"Stored memory with tags: {', '.join(tags)}"