erlangshen 0.1.0

package/src/api/server.py

@@ -0,0 +1,266 @@
+"""
+FastAPI Server - 二郎神API服务
+提供REST API接口
+"""
+import os
+import sys
+from pathlib import Path
+from typing import Optional
+
+# 添加src到路径
+sys.path.insert(0, str(Path(__file__).parent.parent.parent))
+
+from fastapi import FastAPI, HTTPException
+from fastapi.middleware.cors import CORSMiddleware
+from pydantic import BaseModel, Field
+from loguru import logger
+import uvicorn
+
+from src.core.brain import Brain
+from src.core.memory import Memory
+from src.core.knowledge import KnowledgeBase
+from src.core.cerebellum import Cerebellum
+from src.tools.market_tools import MarketTools
+from src.tools.macro_tools import MacroTools
+from src.tools.search_tools import SearchTools
+from src.tools.file_tools import FileTools
+from src.agents.erlang import 二郎神
+
+# 初始化应用
+app = FastAPI(
+    title="二郎神 API",
+    description="全知全能的AI投资智能体API",
+    version="0.1.0",
+)
+
+app.add_middleware(
+    CORSMiddleware,
+    allow_origins=["*"],
+    allow_credentials=True,
+    allow_methods=["*"],
+    allow_headers=["*"],
+)
+
+# 全局实例
+_brain: Optional[Brain] = None
+_memory: Optional[Memory] = None
+_knowledge: Optional[KnowledgeBase] = None
+_cerebellum: Optional[Cerebellum] = None
+_erlangshen: Optional[二郎神] = None
+
+
+def get_erlangshen() -> 二郎神:
+    """获取或初始化二郎神实例"""
+    global _brain, _memory, _knowledge, _cerebellum, _erlangshen
+    if _erlangshen is None:
+        logger.info("Initializing 二郎神...")
+        _brain = Brain()
+        _memory = Memory()
+        _knowledge = KnowledgeBase()
+        _cerebellum = Cerebellum(brain=_brain, memory=_memory, knowledge=_knowledge)
+
+        # 初始化工具
+        market_tools = MarketTools()
+        macro_tools = MacroTools()
+        search_tools = SearchTools()
+        file_tools = FileTools()
+
+        tools = {
+            "market_tools": market_tools,
+            "macro_tools": macro_tools,
+            "search_tools": search_tools,
+            "file_tools": file_tools,
+        }
+
+        _erlangshen = 二郎神(
+            brain=_brain,
+            memory=_memory,
+            knowledge=_knowledge,
+            tools=tools,
+        )
+        logger.info("二郎神 initialized")
+    return _erlangshen
+
+
+# === 请求/响应模型 ===
+
+class AnalyzeRequest(BaseModel):
+    query: str = Field(description="分析问题")
+    context: Optional[dict] = Field(default=None, description="额外上下文")
+
+
+class AnalyzeResponse(BaseModel):
+    status: str
+    result: dict
+
+
+class MarketRequest(BaseModel):
+    symbol: str = Field(description="股票代码")
+    days: int = Field(default=30, description="历史天数")
+
+
+class ReportRequest(BaseModel):
+    title: str = Field(description="报告标题")
+    content: str = Field(description="报告内容")
+
+
+class ThinkRequest(BaseModel):
+    prompt: str = Field(description="用户输入")
+    context: Optional[dict] = Field(default=None, description="额外上下文")
+    system: Optional[str] = Field(default=None, description="系统提示")
+
+
+# === API端点 ===
+
+@app.get("/")
+async def root():
+    """API根路径"""
+    return {
+        "name": "二郎神 API",
+        "version": "0.1.0",
+        "status": "running",
+    }
+
+
+@app.get("/health")
+async def health():
+    """健康检查"""
+    return {"status": "healthy"}
+
+
+@app.post("/api/brain/think")
+async def brain_think(request: ThinkRequest):
+    """
+    直接调用 Brain 进行深度思考
+    前端全息界面调用此接口
+    """
+    try:
+        erlangshen = get_erlangshen()
+        result = await erlangshen.brain.think(
+            prompt=request.prompt,
+            context=request.context,
+            system=request.system,
+        )
+        return {"status": "success", "result": result}
+    except Exception as e:
+        logger.error(f"Brain think failed: {e}")
+        raise HTTPException(status_code=500, detail=str(e))
+
+
+@app.post("/analyze", response_model=AnalyzeResponse)
+async def analyze(request: AnalyzeRequest):
+    """
+    分析接口 - 二郎神的核心分析能力
+
+    支持:
+    - 宏观经济分析
+    - 股票分析
+    - 多资产配置建议
+    - 综合投资分析
+    """
+    try:
+        erlangshen = get_erlangshen()
+        result = await erlangshen.process(request.query, request.context)
+        return AnalyzeResponse(status="success", result=result)
+    except Exception as e:
+        logger.error(f"Analyze failed: {e}")
+        raise HTTPException(status_code=500, detail=str(e))
+
+
+@app.post("/query")
+async def query(request: AnalyzeRequest):
+    """
+    查询接口 - 简化的查询接口
+    """
+    try:
+        erlangshen = get_erlangshen()
+        result = await erlangshen.process(request.query, request.context)
+        return result
+    except Exception as e:
+        logger.error(f"Query failed: {e}")
+        raise HTTPException(status_code=500, detail=str(e))
+
+
+@app.get("/market/{symbol}")
+async def get_market(symbol: str, days: int = 30):
+    """获取股票行情"""
+    try:
+        erlangshen = get_erlangshen()
+        market_tools = erlangshen.tools.get("market_tools")
+        if market_tools:
+            result = await market_tools.get_stock_history(symbol, days)
+            return result
+        raise HTTPException(status_code=503, detail="Market tools not available")
+    except Exception as e:
+        logger.error(f"Market query failed: {e}")
+        raise HTTPException(status_code=500, detail=str(e))
+
+
+@app.get("/macro/{indicator}")
+async def get_macro(indicator: str):
+    """获取宏观指标"""
+    try:
+        erlangshen = get_erlangshen()
+        macro_tools = erlangshen.tools.get("macro_tools")
+        if macro_tools:
+            result = await macro_tools.get_macro_indicator(indicator)
+            return result
+        raise HTTPException(status_code=503, detail="Macro tools not available")
+    except Exception as e:
+        logger.error(f"Macro query failed: {e}")
+        raise HTTPException(status_code=500, detail=str(e))
+
+
+@app.post("/report")
+async def create_report(request: ReportRequest):
+    """创建报告"""
+    try:
+        erlangshen = get_erlangshen()
+        result = await erlangshen.generate_report(request.title, request.content)
+        return result
+    except Exception as e:
+        logger.error(f"Report creation failed: {e}")
+        raise HTTPException(status_code=500, detail=str(e))
+
+
+@app.get("/knowledge/stats")
+async def knowledge_stats():
+    """知识库统计"""
+    try:
+        erlangshen = get_erlangshen()
+        if erlangshen.knowledge:
+            return erlangshen.knowledge.stats()
+        raise HTTPException(status_code=503, detail="Knowledge not available")
+    except Exception as e:
+        logger.error(f"Knowledge stats failed: {e}")
+        raise HTTPException(status_code=500, detail=str(e))
+
+
+@app.get("/memory/stats")
+async def memory_stats():
+    """记忆统计"""
+    try:
+        erlangshen = get_erlangshen()
+        if erlangshen.memory:
+            return erlangshen.memory.export_state()
+        raise HTTPException(status_code=503, detail="Memory not available")
+    except Exception as e:
+        logger.error(f"Memory stats failed: {e}")
+        raise HTTPException(status_code=500, detail=str(e))
+
+
+# === 启动函数 ===
+
+def run_server(host: str = "0.0.0.0", port: int = 8000):
+    """启动API服务器"""
+    logger.info(f"Starting 二郎神 API server on {host}:{port}")
+    uvicorn.run(app, host=host, port=port)
+
+
+if __name__ == "__main__":
+    import argparse
+    parser = argparse.ArgumentParser(description="二郎神API服务器")
+    parser.add_argument("--host", default="0.0.0.0", help="监听地址")
+    parser.add_argument("--port", type=int, default=8000, help="监听端口")
+    args = parser.parse_args()
+    run_server(args.host, args.port)

package/src/brain.py

@@ -0,0 +1,200 @@
+"""
+二郎神大脑 - LLM调用层
+"""
+
+import os
+import json
+from typing import Optional, List, Dict, Any
+from pathlib import Path
+
+from src.config import get_config
+
+
+class Brain:
+    """
+    二郎神大脑 - 统一的LLM调用接口
+    支持 DeepSeek、OpenAI 等多种模型
+    """
+    
+    def __init__(self):
+        self.config = get_config()
+        self.max_context = self.config.llm_max_context  # 1M tokens for deepseek-v4-pro
+        self._client = None
+        self.conversation_history: List[Dict[str, str]] = []
+    
+    @property
+    def client(self):
+        """懒加载 LLM 客户端"""
+        if self._client is None:
+            self._client = self._create_client()
+        return self._client
+    
+    def _create_client(self):
+        """创建 LLM 客户端"""
+        provider = self.config.llm_provider.lower()
+        
+        if provider == "deepseek":
+            try:
+                from openai import OpenAI
+                # 优先使用环境变量
+                api_key = os.environ.get("DEEPSEEK_API_KEY") or self.config.deepseek_api_key
+                return OpenAI(
+                    api_key=api_key,
+                    base_url="https://api.deepseek.com"
+                )
+            except ImportError:
+                raise ImportError("请安装 openai: pip install openai")
+        
+        elif provider == "openai":
+            try:
+                from openai import OpenAI
+                return OpenAI(
+                    api_key=self.config.llm_api_key or os.environ.get("OPENAI_API_KEY"),
+                    base_url=self.config.llm_base_url
+                )
+            except ImportError:
+                raise ImportError("请安装 openai: pip install openai")
+        
+        else:
+            raise ValueError(f"不支持的 LLM 提供商: {provider}")
+    
+    def _get_model(self) -> str:
+        """获取模型名称"""
+        if self.config.llm_provider.lower() == "deepseek":
+            # 优先使用环境变量
+            return os.environ.get("DEEPSEEK_MODEL") or self.config.deepseek_model
+        return self.config.llm_model
+    
+    async def think(
+        self,
+        prompt: str,
+        system: Optional[str] = None,
+        temperature: Optional[float] = None,
+        max_tokens: Optional[int] = None,
+        context: Optional[List[Dict[str, str]]] = None,
+    ) -> str:
+        """
+        核心思考方法
+        
+        Args:
+            prompt: 用户提示
+            system: 系统提示 (可选)
+            temperature: 温度参数 (可选)
+            max_tokens: 最大 token 数 (可选)
+            context: 对话上下文 (可选)
+        
+        Returns:
+            LLM 生成的响应
+        """
+        messages = []
+        
+        # 系统提示
+        if system:
+            messages.append({"role": "system", "content": system})
+        
+        # 上下文
+        if context:
+            messages.extend(context)
+        
+        # 用户提示
+        messages.append({"role": "user", "content": prompt})
+        
+        try:
+            response = self.client.chat.completions.create(
+                model=self._get_model(),
+                messages=messages,
+                temperature=temperature or self.config.llm_temperature,
+                max_tokens=max_tokens or self.config.llm_max_tokens,
+            )
+            
+            return response.choices[0].message.content
+        
+        except Exception as e:
+            return f"思考过程出错: {str(e)}"
+    
+    async def analyze(
+        self,
+        query: str,
+        framework: Optional[str] = None,
+        data: Optional[Dict[str, Any]] = None,
+    ) -> str:
+        """
+        分析查询
+        
+        Args:
+            query: 分析查询
+            framework: 分析框架 (可选)
+            data: 相关数据 (可选)
+        
+        Returns:
+            分析结果
+        """
+        system_prompt = self._build_analysis_prompt(framework)
+        
+        user_prompt = query
+        if data:
+            user_prompt += f"\n\n相关数据:\n{json.dumps(data, ensure_ascii=False, indent=2)}"
+        
+        return await self.think(user_prompt, system=system_prompt)
+    
+    def _build_analysis_prompt(self, framework: Optional[str] = None) -> str:
+        """构建分析提示"""
+        base = """你是二郎神，一个全知全能的AI投资智能体。
+
+## 你的背景
+- 你是小二配置团队的AI投资智能体
+- 你具备团队全貌认知，了解9个专业Agent的能力和成果
+- 你可以调用真实数据库获取行情和宏观数据
+
+## 团队能力
+- Agent-01/02: 基金筛选配置（ETF轮动V7年化16.1%）
+- Agent-03: 交易执行验证
+- Agent-04: CTA量化策略
+- Agent-05: 宏观策略（V19年化25.6%，净值5.23）
+- Agent-07: 数据采集治理
+- Agent-08: 客户服务
+- Agent-09: 个股基本面研究
+
+## 核心数据资源
+- 宏观数据库: 48个指标，SHIBOR_3M/CPI/GDP/PMI等
+- 远程行情: 股票/指数/期货实时数据
+- MCP工具: 东方财富dc-66，飞书文档
+
+## 分析原则
+1. 基于真实数据进行分析
+2. 客观中立，不带偏见
+3. 风险与收益并重
+4. 考虑多种情景和可能性
+5. 可以调用团队各Agent的专业能力
+
+输出格式:
+- 核心观点 (1-3句话)
+- 详细分析
+- 风险提示
+- 行动建议 (如适用)
+"""
+        
+        if framework:
+            base += f"\n\n分析框架: {framework}"
+        
+        return base
+    
+    def reset_history(self):
+        """重置对话历史"""
+        self.conversation_history = []
+    
+    def add_to_history(self, role: str, content: str):
+        """添加到对话历史"""
+        self.conversation_history.append({"role": role, "content": content})
+    
+    async def think_with_history(
+        self,
+        prompt: str,
+        system: Optional[str] = None,
+    ) -> str:
+        """带历史的思考"""
+        return await self.think(
+            prompt,
+            system=system,
+            context=self.conversation_history
+        )

package/src/cli.py

@@ -0,0 +1,153 @@
+#!/usr/bin/env python3
+"""
+二郎神 CLI - 投资分析智能体命令行入口
+"""
+
+import sys
+import asyncio
+import os
+from typing import Optional
+
+from src.brain import Brain
+from src.mcp.registry import MCPRegistry
+from src.commands.analyze import AnalyzeCommand
+from src.commands.macro import MacroCommand
+from src.commands.stock import StockCommand
+from src.commands.report import ReportCommand
+from src.commands.search import SearchCommand
+from src.commands.portfolio import PortfolioCommand
+from src.commands.risk import RiskCommand
+from src.commands.memo import MemoCommand
+from src.hooks.session_start import SessionStartHook
+from src.hooks.session_end import SessionEndHook
+
+
+class CLI:
+    """二郎神 CLI 主类"""
+    
+    COMMANDS = {
+        "analyze": AnalyzeCommand,
+        "macro": MacroCommand,
+        "stock": StockCommand,
+        "report": ReportCommand,
+        "search": SearchCommand,
+        "portfolio": PortfolioCommand,
+        "risk": RiskCommand,
+        "memo": MemoCommand,
+    }
+    
+    def __init__(self):
+        self.brain = Brain()
+        self.mcp = MCPRegistry()
+        self.hooks = {
+            "session_start": SessionStartHook(self.brain, self.mcp),
+            "session_end": SessionEndHook(self.brain, self.mcp),
+        }
+    
+    async def run_command(self, command: str, args: str) -> str:
+        """执行命令"""
+        if command in self.COMMANDS:
+            cmd = self.COMMANDS[command](self.brain, self.mcp)
+            return await cmd.execute(args)
+        else:
+            return f"未知命令: /{command}\n\n可用命令:\n" + "\n".join(f"  /{cmd}" for cmd in self.COMMANDS.keys())
+    
+    async def interactive_mode(self):
+        """交互模式"""
+        print("二郎神 v0.1.0 - 投资分析智能体")
+        print("输入 /help 查看帮助，输入 /exit 退出\n")
+        
+        # Session start hook
+        await self.hooks["session_start"].run()
+        
+        while True:
+            try:
+                user_input = input("二郎神> ").strip()
+                
+                if not user_input:
+                    continue
+                
+                if user_input in ["/exit", "/quit", "/q"]:
+                    print("再见!")
+                    break
+                
+                if user_input == "/help":
+                    self.print_help()
+                    continue
+                
+                # 处理斜杠命令
+                if user_input.startswith("/"):
+                    parts = user_input[1:].split(maxsplit=1)
+                    command = parts[0]
+                    args = parts[1] if len(parts) > 1 else ""
+                    result = await self.run_command(command, args)
+                else:
+                    # 默认执行分析
+                    result = await self.run_command("analyze", user_input)
+                
+                print(f"\n{result}\n")
+                
+            except KeyboardInterrupt:
+                print("\n\n再见!")
+                break
+            except Exception as e:
+                print(f"\n错误: {e}\n")
+        
+        # Session end hook
+        await self.hooks["session_end"].run()
+    
+    def print_help(self):
+        """打印帮助信息"""
+        print("""
+二郎神 - 投资分析智能体
+
+可用命令:
+  /analyze <query>   综合分析 (默认)
+  /macro <query>     宏观分析
+  /stock <query>     股票分析
+  /report <query>    报告生成
+  /search <query>    搜索
+  /portfolio <query> 组合分析
+  /risk <query>      风险分析
+  /memo <query>      纪要管理
+
+示例:
+  二郎神 /analyze A股当前走势
+  二郎神 /macro CPI走势
+  二郎神 /stock 茅台
+  二郎神 /report 月度报告
+""")
+
+
+def main():
+    """主入口"""
+    cli = CLI()
+    
+    if len(sys.argv) > 1:
+        command = sys.argv[1]
+        
+        if command == "--help" or command == "-h":
+            cli.print_help()
+            return
+        
+        if command.startswith("/"):
+            # 斜杠命令格式
+            cmd_parts = command[1:].split(maxsplit=1)
+            cmd = cmd_parts[0]
+            args = cmd_parts[1] if len(cmd_parts) > 1 else ""
+            if len(sys.argv) > 2:
+                args = (args + " " + " ".join(sys.argv[2:])).strip() if args else " ".join(sys.argv[2:])
+            result = asyncio.run(cli.run_command(cmd, args))
+        else:
+            # 非斜杠命令格式
+            args = " ".join(sys.argv[1:])
+            result = asyncio.run(cli.run_command("analyze", args))
+        
+        print(result)
+    else:
+        # 交互模式
+        asyncio.run(cli.interactive_mode())
+
+
+if __name__ == "__main__":
+    main()

package/src/commands/__init__.py

@@ -0,0 +1,3 @@
+"""
+Commands 模块
+"""