aetherforge-platform 1.0.0__py3-none-any.whl

ai-life-assistant-copy/backups/backup_20260404_193836/memory_v2.py

@@ -0,0 +1,333 @@
+import json
+import os
+from typing import List, Dict, Any, Optional
+from datetime import datetime, timedelta
+from enum import Enum
+
+class MemoryType(Enum):
+    USER = "user"
+    FEEDBACK = "feedback"
+    PROJECT = "project"
+    REFERENCE = "reference"
+
+class Memory:
+    def __init__(
+        self,
+        name: str,
+        description: str,
+        memory_type: MemoryType,
+        content: str,
+        created_at: Optional[str] = None,
+        updated_at: Optional[str] = None,
+        importance: float = 0.5,
+        access_count: int = 0
+    ):
+        self.name = name
+        self.description = description
+        self.memory_type = memory_type
+        self.content = content
+        self.created_at = created_at or datetime.now().isoformat()
+        self.updated_at = updated_at or datetime.now().isoformat()
+        self.importance = importance  # 0.0 - 1.0，记忆重要性
+        self.access_count = access_count  # 被访问次数
+    
+    def to_dict(self) -> Dict[str, Any]:
+        return {
+            "name": self.name,
+            "description": self.description,
+            "type": self.memory_type.value,
+            "content": self.content,
+            "created_at": self.created_at,
+            "updated_at": self.updated_at,
+            "importance": self.importance,
+            "access_count": self.access_count
+        }
+    
+    @classmethod
+    def from_dict(cls, data: Dict[str, Any]) -> "Memory":
+        return cls(
+            name=data["name"],
+            description=data["description"],
+            memory_type=MemoryType(data["type"]),
+            content=data["content"],
+            created_at=data.get("created_at"),
+            updated_at=data.get("updated_at"),
+            importance=data.get("importance", 0.5),
+            access_count=data.get("access_count", 0)
+        )
+    
+    def get_age_in_days(self) -> float:
+        created = datetime.fromisoformat(self.created_at)
+        now = datetime.now()
+        return (now - created).total_seconds() / 86400
+    
+    def get_recency_score(self) -> float:
+        age_days = self.get_age_in_days()
+        if age_days < 1:
+            return 1.0
+        elif age_days < 7:
+            return 0.8
+        elif age_days < 30:
+            return 0.5
+        elif age_days < 90:
+            return 0.2
+        else:
+            return 0.05
+    
+    def get_relevance_score(self, query: str) -> float:
+        query_lower = query.lower()
+        content_lower = self.content.lower()
+        name_lower = self.name.lower()
+        
+        score = 0.0
+        if query_lower in content_lower:
+            score += 0.6
+        if query_lower in name_lower:
+            score += 0.3
+        
+        score += self.importance * 0.3
+        score += self.get_recency_score() * 0.4
+        
+        return min(1.0, score)
+    
+    def to_markdown(self) -> str:
+        frontmatter = f"""---
+name: {self.name}
+description: {self.description}
+type: {self.memory_type.value}
+---
+
+{self.content}
+"""
+        return frontmatter
+
+class MemorySystemV2:
+    def __init__(self, memory_dir: str = "user_memory_v2"):
+        self.memory_dir = memory_dir
+        if not os.path.exists(memory_dir):
+            os.makedirs(memory_dir)
+        
+        for mem_type in MemoryType:
+            type_dir = os.path.join(memory_dir, mem_type.value)
+            if not os.path.exists(type_dir):
+                os.makedirs(type_dir)
+    
+    def _get_memory_path(self, user_id: str, memory_type: MemoryType, name: str) -> str:
+        safe_name = "".join(c for c in name if c.isalnum() or c in (" ", "-", "_")).rstrip()
+        safe_name = safe_name.replace(" ", "_")
+        return os.path.join(self.memory_dir, memory_type.value, f"{user_id}_{safe_name}.json")
+    
+    def _get_all_memory_files(self, user_id: str, memory_type: Optional[MemoryType] = None) -> List[str]:
+        files = []
+        types_to_check = [memory_type] if memory_type else list(MemoryType)
+        
+        for mem_type in types_to_check:
+            type_dir = os.path.join(self.memory_dir, mem_type.value)
+            if os.path.exists(type_dir):
+                for filename in os.listdir(type_dir):
+                    if filename.startswith(f"{user_id}_") and filename.endswith(".json"):
+                        files.append(os.path.join(type_dir, filename))
+        
+        return files
+    
+    def add_memory(self, user_id: str, memory: Memory) -> bool:
+        try:
+            file_path = self._get_memory_path(user_id, memory.memory_type, memory.name)
+            with open(file_path, "w", encoding="utf-8") as f:
+                json.dump(memory.to_dict(), f, ensure_ascii=False, indent=2)
+            return True
+        except Exception as e:
+            print(f"Error adding memory: {e}")
+            return False
+    
+    def get_memory(self, user_id: str, memory_type: MemoryType, name: str) -> Optional[Memory]:
+        file_path = self._get_memory_path(user_id, memory_type, name)
+        if os.path.exists(file_path):
+            with open(file_path, "r", encoding="utf-8") as f:
+                data = json.load(f)
+                return Memory.from_dict(data)
+        return None
+    
+    def get_all_memories(self, user_id: str, memory_type: Optional[MemoryType] = None) -> List[Memory]:
+        memories = []
+        files = self._get_all_memory_files(user_id, memory_type)
+        
+        for file_path in files:
+            try:
+                with open(file_path, "r", encoding="utf-8") as f:
+                    data = json.load(f)
+                    memories.append(Memory.from_dict(data))
+            except Exception as e:
+                print(f"Error reading memory {file_path}: {e}")
+        
+        return sorted(memories, key=lambda m: m.updated_at, reverse=True)
+    
+    def delete_memory(self, user_id: str, memory_type: MemoryType, name: str) -> bool:
+        file_path = self._get_memory_path(user_id, memory_type, name)
+        if os.path.exists(file_path):
+            os.remove(file_path)
+            return True
+        return False
+    
+    def search_memories(self, user_id: str, query: str, memory_type: Optional[MemoryType] = None) -> List[Memory]:
+        memories = self.get_all_memories(user_id, memory_type)
+        query_lower = query.lower()
+        
+        results = []
+        for memory in memories:
+            if (query_lower in memory.name.lower() or
+                query_lower in memory.description.lower() or
+                query_lower in memory.content.lower()):
+                results.append(memory)
+        
+        return results
+    
+    def get_relevant_context(self, user_id: str, current_message: str, min_relevance: float = 0.3) -> str:
+        context_parts = []
+        all_memories = self.get_all_memories(user_id)
+        
+        if not all_memories:
+            return ""
+        
+        try:
+            from langchain_groq import ChatGroq
+            from langchain.prompts import ChatPromptTemplate
+            from config import GROK_API_KEY
+            
+            llm = ChatGroq(
+                api_key=GROK_API_KEY,
+                model="mixtral-8x7b-32768"
+            )
+            
+            memories_text = "\n".join([
+                f"[{i}] {mem.memory_type.value}: {mem.content}"
+                for i, mem in enumerate(all_memories[:10])
+            ])
+            
+            prompt = ChatPromptTemplate.from_messages([
+                ("system", """你是一个非常谨慎的记忆筛选专家。
+
+当前用户消息: {current_message}
+
+可用记忆:
+{memories_text}
+
+重要原则：
+1. 只有当记忆对回答当前问题**绝对必要**时才选
+2. 如果不用这个记忆也能回答，就不要选
+3. 不要让 AI 听起来像是在刻意展示它知道用户的事情
+4. 优先考虑：不用记忆，让 AI 自然地回答
+
+请返回一个 JSON 数组，包含真正必要的记忆索引（从0开始）。
+格式示例: [0]
+
+如果没有真正必要的记忆，返回空数组: []
+
+只返回 JSON，不要其他文字。"""),
+            ])
+            
+            chain = prompt | llm
+            response = chain.invoke({
+                "current_message": current_message,
+                "memories_text": memories_text
+            })
+            
+            try:
+                relevant_indices = json.loads(response.content.strip())
+                if not isinstance(relevant_indices, list):
+                    relevant_indices = []
+            except json.JSONDecodeError:
+                relevant_indices = []
+            
+            selected_memories = []
+            for idx in relevant_indices:
+                if 0 <= idx < len(all_memories):
+                    selected_memories.append(all_memories[idx])
+            
+            if selected_memories:
+                context_parts.append("【用户背景信息 - 请自然地使用这些信息，不要刻意提及或展示】")
+            
+            for mem_type in MemoryType:
+                type_memories = [m for m in selected_memories if m.memory_type == mem_type]
+                if type_memories:
+                    for mem in type_memories[:2]:
+                        mem.access_count += 1
+                        self.add_memory(user_id, mem)
+                        context_parts.append(f"- {mem.content}")
+            
+            if context_parts:
+                return "\n".join(context_parts)
+            return ""
+            
+        except Exception as e:
+            print(f"LLM relevance check error: {e}")
+            return ""
+    
+    def _get_relevant_context_fallback(self, user_id: str, current_message: str, min_relevance: float = 0.3) -> str:
+        context_parts = []
+        all_memories = self.get_all_memories(user_id)
+        
+        for memory in all_memories:
+            relevance = memory.get_relevance_score(current_message)
+            memory.relevance_score = relevance
+        
+        filtered_memories = [m for m in all_memories if hasattr(m, 'relevance_score') and m.relevance_score >= min_relevance]
+        sorted_memories = sorted(filtered_memories, key=lambda m: m.relevance_score, reverse=True)
+        
+        for mem_type in MemoryType:
+            type_memories = [m for m in sorted_memories if m.memory_type == mem_type]
+            if type_memories:
+                section_title = {
+                    MemoryType.USER: "## 用户信息",
+                    MemoryType.FEEDBACK: "## 用户反馈",
+                    MemoryType.PROJECT: "## 项目信息",
+                    MemoryType.REFERENCE: "## 参考链接"
+                }[mem_type]
+                context_parts.append(section_title)
+                
+                for mem in type_memories[:4]:
+                    mem.access_count += 1
+                    self.add_memory(user_id, mem)
+                    context_parts.append(f"- {mem.name}: {mem.content}")
+        
+        if context_parts:
+            return "\n".join(context_parts)
+        return "暂无相关记忆"
+    
+    def extract_and_save_memory(self, user_id: str, message: str, response: str):
+        message_lower = message.lower()
+        
+        importance = 0.5
+        if "永远" in message_lower or "绝对" in message_lower or "绝不" in message_lower:
+            importance = 0.9
+        elif "非常" in message_lower or "特别" in message_lower:
+            importance = 0.75
+        
+        user_keywords = ["我是", "我喜欢", "我偏好", "我不喜欢", "我讨厌", "我想要", "我爱吃", "我爱玩"]
+        for keyword in user_keywords:
+            if keyword in message_lower:
+                memory = Memory(
+                    name=f"用户偏好_{datetime.now().strftime('%Y%m%d_%H%M%S')}",
+                    description="用户表达的偏好",
+                    memory_type=MemoryType.USER,
+                    content=message,
+                    importance=importance
+                )
+                self.add_memory(user_id, memory)
+                break
+        
+        feedback_keywords = ["不要", "别", "停止", "就这样", "对", "是的", "完美", "很好", "不行"]
+        for keyword in feedback_keywords:
+            if keyword in message_lower:
+                memory = Memory(
+                    name=f"用户反馈_{datetime.now().strftime('%Y%m%d_%H%M%S')}",
+                    description="用户的反馈",
+                    memory_type=MemoryType.FEEDBACK,
+                    content=f"用户说: {message}\nAI回复: {response[:200]}...",
+                    importance=importance
+                )
+                self.add_memory(user_id, memory)
+                break
+
+
+memory_system_v2 = MemorySystemV2()

ai-life-assistant-copy/backups/backup_20260404_193836/mock_shopping_data.py

@@ -0,0 +1,172 @@
+"""
+模拟购物数据 - 开发阶段使用
+不需要真实 API Key，先把功能做出来
+"""
+
+import random
+from datetime import datetime, timedelta
+
+MOCK_PRODUCTS = [
+    {
+        "id": "B081F5Z8P2",
+        "title": "NVIDIA GeForce RTX 4060 Ti 8GB GDDR6",
+        "description": "Next-gen gaming GPU with DLSS 3 and ray tracing",
+        "price": 399.99,
+        "originalPrice": 449.99,
+        "currency": "USD",
+        "image": "https://images.unsplash.com/photo-1591488320449-011701bb6704?w=300&h=300&fit=crop",
+        "url": "https://amazon.com/dp/B081F5Z8P2",
+        "platform": "Amazon",
+        "rating": 4.5,
+        "reviewCount": 2847,
+        "inStock": True,
+        "priceChange": -11.1,
+        "priceChangeDirection": "down"
+    },
+    {
+        "id": "B09XYZ1234",
+        "title": "NVIDIA GeForce RTX 4060 Ti 8GB - Brand New",
+        "description": "Factory sealed, free shipping",
+        "price": 379.99,
+        "originalPrice": 399.99,
+        "currency": "USD",
+        "image": "https://images.unsplash.com/photo-1587202372775-e229f1d21684?w=300&h=300&fit=crop",
+        "url": "https://ebay.com/itm/1234567890",
+        "platform": "Ebay",
+        "rating": 4.8,
+        "reviewCount": 15234,
+        "inStock": True,
+        "priceChange": -5.0,
+        "priceChangeDirection": "down"
+    },
+    {
+        "id": "BBY6543210",
+        "title": "NVIDIA - GeForce RTX 4060 Ti 8GB GDDR6",
+        "description": "In-store pickup available today",
+        "price": 389.99,
+        "originalPrice": 399.99,
+        "currency": "USD",
+        "image": "https://images.unsplash.com/photo-1550745165-9bc0b252726f?w=300&h=300&fit=crop",
+        "url": "https://bestbuy.com/site/6543210.p",
+        "platform": "Best Buy",
+        "rating": 4.6,
+        "reviewCount": 847,
+        "inStock": True,
+        "priceChange": -2.5,
+        "priceChangeDirection": "down"
+    },
+    {
+        "id": "AMZ9876543",
+        "title": "Apple AirPods Pro (2nd Generation)",
+        "description": "Active noise cancellation, spatial audio",
+        "price": 199.99,
+        "originalPrice": 249.99,
+        "currency": "USD",
+        "image": "https://images.unsplash.com/photo-1572569511254-d8f925fe2cbb?w=300&h=300&fit=crop",
+        "url": "https://amazon.com/dp/AMZ9876543",
+        "platform": "Amazon",
+        "rating": 4.9,
+        "reviewCount": 45231,
+        "inStock": True,
+        "priceChange": -20.0,
+        "priceChangeDirection": "down"
+    },
+    {
+        "id": "BBY1234567",
+        "title": "Sony WH-1000XM5 Wireless Headphones",
+        "description": "Industry-leading noise cancellation",
+        "price": 328.00,
+        "originalPrice": 399.99,
+        "currency": "USD",
+        "image": "https://images.unsplash.com/photo-1505740420928-5e560c06d30e?w=300&h=300&fit=crop",
+        "url": "https://bestbuy.com/site/1234567.p",
+        "platform": "Best Buy",
+        "rating": 4.7,
+        "reviewCount": 12453,
+        "inStock": True,
+        "priceChange": -18.0,
+        "priceChangeDirection": "down"
+    }
+]
+
+
+def search_mock_products(keyword):
+    """
+    模拟产品搜索
+    """
+    results = []
+    keyword_lower = keyword.lower()
+    
+    for product in MOCK_PRODUCTS:
+        if (keyword_lower in product["title"].lower() or 
+            keyword_lower in product["description"].lower()):
+            results.append(product)
+    
+    if not results:
+        results = MOCK_PRODUCTS[:3]
+    
+    return {
+        "success": True,
+        "keyword": keyword,
+        "results": results,
+        "total_count": len(results)
+    }
+
+
+def get_price_history(product_id, days=30):
+    """
+    模拟价格历史数据
+    """
+    base_price = next((p["price"] for p in MOCK_PRODUCTS if p["id"] == product_id), 100)
+    
+    history = []
+    today = datetime.now()
+    
+    for i in range(days):
+        date = today - timedelta(days=i)
+        price_variation = random.uniform(-0.1, 0.1)
+        price = base_price * (1 + price_variation)
+        
+        history.append({
+            "date": date.strftime("%Y-%m-%d"),
+            "price": round(price, 2)
+        })
+    
+    return {
+        "success": True,
+        "product_id": product_id,
+        "history": list(reversed(history))
+    }
+
+
+def compare_prices(product_name):
+    """
+    模拟多平台价格比较
+    """
+    amazon_price = random.uniform(180, 220)
+    ebay_price = random.uniform(170, 210)
+    bestbuy_price = random.uniform(175, 225)
+    
+    prices = [
+        {"platform": "Amazon", "price": round(amazon_price, 2), "url": "https://amazon.com"},
+        {"platform": "Ebay", "price": round(ebay_price, 2), "url": "https://ebay.com"},
+        {"platform": "Best Buy", "price": round(bestbuy_price, 2), "url": "https://bestbuy.com"}
+    ]
+    
+    prices_sorted = sorted(prices, key=lambda x: x["price"])
+    lowest_price = prices_sorted[0]
+    
+    return {
+        "success": True,
+        "product_name": product_name,
+        "prices": prices,
+        "lowest_price": lowest_price,
+        "savings": round(prices_sorted[-1]["price"] - lowest_price["price"], 2)
+    }
+
+
+if __name__ == "__main__":
+    results = search_mock_products("4060")
+    print(f"Found {results['total_count']} products:")
+    for product in results["results"]:
+        print(f"  - {product['title']} ({product['platform']}): ${product['price']}")

ai-life-assistant-copy/backups/backup_20260404_193836/personality.py

@@ -0,0 +1,159 @@
+import json
+import os
+from typing import Dict, List, Any, Optional
+from enum import Enum
+from datetime import datetime
+from config import GROK_API_KEY
+
+class PersonalityTrait(Enum):
+    EXTROVERSION = "extroversion"
+    AGREEABLENESS = "agreeableness"
+    CONSCIENTIOUSNESS = "conscientiousness"
+    NEUROTICISM = "neuroticism"
+    OPENNESS = "openness"
+
+class InterestCategory(Enum):
+    TECH = "tech"
+    SPORTS = "sports"
+    MUSIC = "music"
+    MOVIES = "movies"
+    BOOKS = "books"
+    TRAVEL = "travel"
+    FOOD = "food"
+    GAMES = "games"
+    ART = "art"
+    FITNESS = "fitness"
+
+class PersonalityAnalyzer:
+    def __init__(self, data_dir: str = "personality_data"):
+        self.data_dir = data_dir
+        if not os.path.exists(data_dir):
+            os.makedirs(data_dir)
+    
+    def _get_user_file(self, user_id: str) -> str:
+        return os.path.join(self.data_dir, f"{user_id}_personality.json")
+    
+    def analyze_conversation(self, user_id: str, messages: List[Dict[str, str]]) -> Dict[str, Any]:
+        try:
+            from langchain_groq import ChatGroq
+            from langchain.prompts import ChatPromptTemplate
+            
+            llm = ChatGroq(
+                api_key=GROK_API_KEY,
+                model="mixtral-8x7b-32768"
+            )
+            
+            conversation_text = "\n".join([
+                f"{msg['role']}: {msg['content']}" 
+                for msg in messages[-30:]
+            ])
+            
+            prompt = ChatPromptTemplate.from_messages([
+                ("system", """你是一个专业的性格分析师。请分析用户的对话记录，评估用户的性格特征。
+
+请以 JSON 格式返回分析结果，包含以下字段：
+{{
+    "big_five": {{
+        "extroversion": 0-100,
+        "agreeableness": 0-100,
+        "conscientiousness": 0-100,
+        "neuroticism": 0-100,
+        "openness": 0-100
+    }},
+    "interests": ["兴趣1", "兴趣2", ...],
+    "communication_style": "沟通风格描述",
+    "values": ["价值观1", "价值观2", ...],
+    "summary": "简短的性格总结"
+}}
+
+只返回 JSON，不要其他文字。"""),
+                ("human", "对话记录：\n\n{conversation}")
+            ])
+            
+            chain = prompt | llm
+            response = chain.invoke({"conversation": conversation_text})
+            
+            try:
+                analysis = json.loads(response.content)
+                self._save_analysis(user_id, analysis)
+                return analysis
+            except json.JSONDecodeError:
+                return self._get_default_analysis()
+                
+        except Exception as e:
+            print(f"Personality analysis error: {e}")
+            return self._get_default_analysis()
+    
+    def _get_default_analysis(self) -> Dict[str, Any]:
+        return {
+            "big_five": {
+                "extroversion": 50,
+                "agreeableness": 50,
+                "conscientiousness": 50,
+                "neuroticism": 50,
+                "openness": 50
+            },
+            "interests": [],
+            "communication_style": "中立",
+            "values": [],
+            "summary": "需要更多对话来分析性格"
+        }
+    
+    def _save_analysis(self, user_id: str, analysis: Dict[str, Any]):
+        file_path = self._get_user_file(user_id)
+        analysis["updated_at"] = datetime.now().isoformat()
+        with open(file_path, "w", encoding="utf-8") as f:
+            json.dump(analysis, f, ensure_ascii=False, indent=2)
+    
+    def get_analysis(self, user_id: str) -> Optional[Dict[str, Any]]:
+        file_path = self._get_user_file(user_id)
+        if os.path.exists(file_path):
+            with open(file_path, "r", encoding="utf-8") as f:
+                return json.load(f)
+        return None
+    
+    def calculate_compatibility(self, user1_analysis: Dict[str, Any], user2_analysis: Dict[str, Any]) -> Dict[str, Any]:
+        big_five1 = user1_analysis.get("big_five", {})
+        big_five2 = user2_analysis.get("big_five", {})
+        
+        trait_scores = {}
+        for trait in ["extroversion", "agreeableness", "conscientiousness", "neuroticism", "openness"]:
+            score1 = big_five1.get(trait, 50)
+            score2 = big_five2.get(trait, 50)
+            difference = abs(score1 - score2)
+            trait_scores[trait] = max(0, 100 - difference)
+        
+        interests1 = set(user1_analysis.get("interests", []))
+        interests2 = set(user2_analysis.get("interests", []))
+        common_interests = interests1.intersection(interests2)
+        all_interests = interests1.union(interests2)
+        
+        interest_score = 0
+        if all_interests:
+            interest_score = int((len(common_interests) / len(all_interests)) * 100)
+        
+        overall_score = int(
+            (sum(trait_scores.values()) / len(trait_scores) * 0.6) +
+            (interest_score * 0.4)
+        )
+        
+        return {
+            "overall_score": overall_score,
+            "trait_scores": trait_scores,
+            "interest_score": interest_score,
+            "common_interests": list(common_interests),
+            "compatibility_level": self._get_compatibility_level(overall_score)
+        }
+    
+    def _get_compatibility_level(self, score: int) -> str:
+        if score >= 80:
+            return "非常匹配"
+        elif score >= 60:
+            return "比较匹配"
+        elif score >= 40:
+            return "一般匹配"
+        else:
+            return "不太匹配"
+
+
+personality_analyzer = PersonalityAnalyzer()