From c4e8cfefc731e4f574a09a3878c75484ee89385b Mon Sep 17 00:00:00 2001 From: ben Date: Sat, 16 Aug 2025 10:37:11 +0000 Subject: [PATCH] =?UTF-8?q?feat:=20=E9=87=8D=E6=9E=84=E9=A1=B9=E7=9B=AE?= =?UTF-8?q?=E7=BB=93=E6=9E=84=E5=B9=B6=E6=B7=BB=E5=8A=A0=E6=96=B0=E5=8A=9F?= =?UTF-8?q?=E8=83=BD?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit - 新增Cloudflare AutoRAG/Vectorize集成文档 - 实现Vertex AI记忆银行功能 - 重构项目目录结构，清理无用文件 - 更新README以反映最新架构 - 添加Google ADK集成测试脚本 - 完善需求文档和设计规范 --- MIGRATION_STATUS.md | 136 ++ QUICK_START_GUIDE.md | 236 +++ README.md | 53 +- RELEASE_v2.0.0.md | 197 ++ VERSION | 1 + config/doppler_config.py | 125 +- design/250810.md | 116 + docs/AUTORAG_INTEGRATION_PROMPT.md | 184 ++ docs/GITHUB_PAGES_PUBLISH_PLAN.md | 218 ++ docs/VERTEX_MEMORY_BANK_SETUP.md | 270 +++ .../analysis/meta_analysis_results.txt | 0 docs/analysis/rss_debug_analysis.md | 140 ++ docs/guides/GOOGLE_ADK_MIGRATION_GUIDE.md | 211 ++ .../guides/MIGRATION_PLAN.md | 0 docs/guides/README_jixia_load_balancing.md | 275 +++ requirements.md => docs/requirements.md | 0 examples/data/demo_results_aapl.json | 106 + examples/data/demo_results_msft.json | 106 + examples/data/demo_results_tsla.json | 106 + examples/demo_jixia_load_balancing.py | 283 +++ examples/memory_bank_demo.py | 245 +++ experiments/memory_bank_experiment.py | 275 +++ experiments/memory_bank_test.py | 116 + internal/README.md | 135 ++ ..._Analysis.md => kag_ecosystem_analysis.md} | 0 .../docs_restructure_plan.md | 0 .../documentation_restructure_completion.md | 0 .../python_files_cleanup_plan.md | 0 .../root_docs_cleanup_plan.md | 0 .../Force_Anti_Monologue_Techniques.md | 0 .../historical_analysis}/earlycall.md | 0 .../historical_analysis}/gemini.md | 0 .../index_professional.md | 0 .../historical_analysis}/tianxia.md | 0 .../{ => core}/baxian_sanqing_system_guide.md | 0 internal/{ => core}/fsm.md | 0 internal/{ => core}/fsm_analysis.md | 0 .../comprehensive_development_plan.md | 316 +++ internal/development/comprehensive_plan.md | 159 ++ internal/development/execution_plan_v2.0.0.md | 257 +++ .../comprehensive_cleanup_summary.md | 0 .../rfc_taigong_xinyi_fsm_enhancements.md | 0 ...trategy.md => platform_avatar_strategy.md} | 0 .../api_scheduling_strategy.md | 0 internal/{ => technical}/liao.md | 0 .../rapidapi_yahoo_finance_guide.md | 0 litellm/comprehensive_mcp_test.py | 247 +++ litellm/config.yaml | 26 + litellm/final_mcp_test.py | 119 ++ litellm/list_models.py | 64 + litellm/simple_mcp_server.py | 239 +++ litellm/test_deepwiki_mcp.py | 100 + litellm/test_gpt5_nano.py | 58 + litellm/test_litellm_mcp.py | 66 + litellm/test_mcp_detailed.py | 49 + litellm/test_mcp_endpoint.py | 39 + litellm/test_remote_simple.py | 28 + litellm/testmcp.py | 72 + litellm/testmcp_debug.py | 108 + litellm/testmcp_local.py | 107 + memories.json | 36 + package-lock.json | 1879 +++++++++++++++++ package.json | 31 + qczh_debate_state.json | 39 + query-shushu-book.js | 138 ++ requirements.txt | 20 +- rss_news_collector.py | 268 --- scripts/add_sequence_ids.py | 63 - scripts/cleanup_duplicates.py | 107 - scripts/create_vector_index.js | 35 - scripts/generate_embeddings.py | 75 - scripts/install_swarm.py | 73 - scripts/n8n_combined_dedup_insert.js | 148 -- scripts/n8n_deduplication_fix.js | 85 - scripts/n8n_direct_insert.js | 85 - scripts/n8n_minimal_news.js | 39 - scripts/n8n_safe_insert.js | 54 - scripts/n8n_sequential_id_system.js | 119 -- scripts/n8n_simple_dedup.js | 52 - scripts/n8n_universal_mongo.js | 163 -- scripts/test_openrouter_api.py | 163 -- scripts/test_rapidapi_inventory.py | 297 --- shushu-demo-results.md | 152 ++ src/advanced-example.ts | 340 +++ src/index.ts | 382 ++++ src/jixia/agents/memory_enhanced_agent.py | 535 +++++ src/jixia/config/immortal_api_config.json | 216 ++ src/jixia/debates/adk_debate_test.py | 130 ++ src/jixia/debates/adk_memory_debate.py | 282 +++ src/jixia/debates/adk_real_debate.py | 252 +++ src/jixia/debates/adk_simple_debate.py | 82 + src/jixia/debates/qczh_debate.py | 165 ++ src/jixia/debates/qi_cheng_zhuan_he_debate.py | 341 +++ src/jixia/memory/base_memory_bank.py | 39 + src/jixia/memory/factory.py | 37 + src/jixia/memory/vertex_memory_bank.py | 463 ++++ test-api-example.js | 299 +++ test-hyperdrive-remote.js | 79 + test-hyperdrive.js | 93 + test-shushu-api.sh | 67 + .../test_alpha_vantage_meta.py | 0 tests/test_google_adk.py | 44 + tests/test_memory_bank.py | 147 ++ tests/test_vertex_memory_bank.py | 257 +++ validate-config.js | 107 + wrangler.toml | 16 + 106 files changed, 12243 insertions(+), 1839 deletions(-) create mode 100644 MIGRATION_STATUS.md create mode 100644 QUICK_START_GUIDE.md create mode 100644 RELEASE_v2.0.0.md create mode 100644 VERSION create mode 100644 design/250810.md create mode 100644 docs/AUTORAG_INTEGRATION_PROMPT.md create mode 100644 docs/GITHUB_PAGES_PUBLISH_PLAN.md create mode 100644 docs/VERTEX_MEMORY_BANK_SETUP.md rename meta_analysis_results.txt => docs/analysis/meta_analysis_results.txt (100%) create mode 100644 docs/analysis/rss_debug_analysis.md create mode 100644 docs/guides/GOOGLE_ADK_MIGRATION_GUIDE.md rename MIGRATION_PLAN.md => docs/guides/MIGRATION_PLAN.md (100%) create mode 100644 docs/guides/README_jixia_load_balancing.md rename requirements.md => docs/requirements.md (100%) create mode 100644 examples/data/demo_results_aapl.json create mode 100644 examples/data/demo_results_msft.json create mode 100644 examples/data/demo_results_tsla.json create mode 100644 examples/demo_jixia_load_balancing.py create mode 100644 examples/memory_bank_demo.py create mode 100644 experiments/memory_bank_experiment.py create mode 100644 experiments/memory_bank_test.py create mode 100644 internal/README.md rename internal/analysis/{KAG_Ecosystem_Position_Analysis.md => kag_ecosystem_analysis.md} (100%) rename internal/{ => archive/deprecated_plans}/docs_restructure_plan.md (100%) rename internal/{ => archive/deprecated_plans}/documentation_restructure_completion.md (100%) rename internal/{ => archive/deprecated_plans}/python_files_cleanup_plan.md (100%) rename internal/{ => archive/deprecated_plans}/root_docs_cleanup_plan.md (100%) rename internal/{ => archive/historical_analysis}/Force_Anti_Monologue_Techniques.md (100%) rename internal/{ => archive/historical_analysis}/earlycall.md (100%) rename internal/{ => archive/historical_analysis}/gemini.md (100%) rename internal/{ => archive/historical_analysis}/index_professional.md (100%) rename internal/{ => archive/historical_analysis}/tianxia.md (100%) rename internal/{ => core}/baxian_sanqing_system_guide.md (100%) rename internal/{ => core}/fsm.md (100%) rename internal/{ => core}/fsm_analysis.md (100%) create mode 100644 internal/development/comprehensive_development_plan.md create mode 100644 internal/development/comprehensive_plan.md create mode 100644 internal/development/execution_plan_v2.0.0.md rename internal/{ => migration}/comprehensive_cleanup_summary.md (100%) rename internal/{ => migration}/rfc_taigong_xinyi_fsm_enhancements.md (100%) rename internal/strategies/{Platform_Specific_Avatar_Strategy.md => platform_avatar_strategy.md} (100%) rename internal/{ => technical}/api_scheduling_strategy.md (100%) rename internal/{ => technical}/liao.md (100%) rename internal/{ => technical}/rapidapi_yahoo_finance_guide.md (100%) create mode 100644 litellm/comprehensive_mcp_test.py create mode 100644 litellm/config.yaml create mode 100644 litellm/final_mcp_test.py create mode 100644 litellm/list_models.py create mode 100644 litellm/simple_mcp_server.py create mode 100644 litellm/test_deepwiki_mcp.py create mode 100644 litellm/test_gpt5_nano.py create mode 100644 litellm/test_litellm_mcp.py create mode 100644 litellm/test_mcp_detailed.py create mode 100644 litellm/test_mcp_endpoint.py create mode 100644 litellm/test_remote_simple.py create mode 100644 litellm/testmcp.py create mode 100644 litellm/testmcp_debug.py create mode 100644 litellm/testmcp_local.py create mode 100644 memories.json create mode 100644 package-lock.json create mode 100644 package.json create mode 100644 qczh_debate_state.json create mode 100644 query-shushu-book.js delete mode 100644 rss_news_collector.py delete mode 100644 scripts/add_sequence_ids.py delete mode 100644 scripts/cleanup_duplicates.py delete mode 100644 scripts/create_vector_index.js delete mode 100644 scripts/generate_embeddings.py delete mode 100644 scripts/install_swarm.py delete mode 100644 scripts/n8n_combined_dedup_insert.js delete mode 100644 scripts/n8n_deduplication_fix.js delete mode 100644 scripts/n8n_direct_insert.js delete mode 100644 scripts/n8n_minimal_news.js delete mode 100644 scripts/n8n_safe_insert.js delete mode 100644 scripts/n8n_sequential_id_system.js delete mode 100644 scripts/n8n_simple_dedup.js delete mode 100644 scripts/n8n_universal_mongo.js delete mode 100644 scripts/test_openrouter_api.py delete mode 100644 scripts/test_rapidapi_inventory.py create mode 100644 shushu-demo-results.md create mode 100644 src/advanced-example.ts create mode 100644 src/index.ts create mode 100644 src/jixia/agents/memory_enhanced_agent.py create mode 100644 src/jixia/config/immortal_api_config.json create mode 100644 src/jixia/debates/adk_debate_test.py create mode 100644 src/jixia/debates/adk_memory_debate.py create mode 100644 src/jixia/debates/adk_real_debate.py create mode 100644 src/jixia/debates/adk_simple_debate.py create mode 100644 src/jixia/debates/qczh_debate.py create mode 100644 src/jixia/debates/qi_cheng_zhuan_he_debate.py create mode 100644 src/jixia/memory/base_memory_bank.py create mode 100644 src/jixia/memory/factory.py create mode 100644 src/jixia/memory/vertex_memory_bank.py create mode 100644 test-api-example.js create mode 100644 test-hyperdrive-remote.js create mode 100644 test-hyperdrive.js create mode 100755 test-shushu-api.sh rename test_alpha_vantage_meta.py => tests/test_alpha_vantage_meta.py (100%) create mode 100644 tests/test_google_adk.py create mode 100644 tests/test_memory_bank.py create mode 100644 tests/test_vertex_memory_bank.py create mode 100644 validate-config.js create mode 100644 wrangler.toml diff --git a/MIGRATION_STATUS.md b/MIGRATION_STATUS.md new file mode 100644 index 0000000..8a964f1 --- /dev/null +++ b/MIGRATION_STATUS.md @@ -0,0 +1,136 @@ +# 稷下学宫 Google ADK 迁移状态报告 + +## 📊 迁移进度概览 + +### ✅ 已完成的任务 + +#### 1. 基础设施迁移 +- [x] **Google ADK 安装**: 成功安装 Google ADK 1.10.0 +- [x] **API 密钥配置**: 已在 Doppler 中配置 `GOOGLE_API_KEY` +- [x] **环境验证**: 基础测试通过，智能体创建成功 + +#### 2. 配置系统更新 +- [x] **doppler_config.py 增强**: + - 新增 `get_google_api_key()` 函数 + - 新增 `get_google_genai_config()` 函数 + - 更新 `validate_config()` 支持三种模式： + - `openrouter`: 纯 OpenRouter 模式 + - `google_adk`: 纯 Google ADK 模式 + - `hybrid`: 混合模式（当前使用） + +#### 3. 测试系统建立 +- [x] **基础测试**: `test_google_adk.py` - 验证 ADK 安装和配置 +- [x] **智能体测试**: `adk_debate_test.py` - 八仙智能体创建测试 +- [x] **论道原型**: `adk_simple_debate.py` - 智能体基础功能验证 + +#### 4. 文档更新 +- [x] **README.md**: 新增 Google ADK 安装和配置说明 +- [x] **requirements.txt**: 添加 Google ADK 依赖说明 +- [x] **迁移指南**: 完整的 `GOOGLE_ADK_MIGRATION_GUIDE.md` + +### 🔄 当前状态 + +#### 配置模式 +- **当前模式**: `hybrid` (混合模式) +- **可用服务**: OpenRouter + Google ADK +- **API 密钥状态**: + - ✅ GOOGLE_API_KEY: 已配置 (39字符) + - ✅ OPENROUTER_API_KEY_1: 已配置 + - ✅ RAPIDAPI_KEY: 已配置 + +#### 智能体状态 +- **八仙智能体**: 已成功创建 + - 铁拐李 (逆向思维专家) + - 汉钟离 (平衡协调者) + - 张果老 (历史智慧者) + - 蓝采和 (创新思维者) + - 何仙姑 (直觉洞察者) + - 吕洞宾 (理性分析者) + - 韩湘子 (艺术感知者) + - 曹国舅 (实务执行者) +- **使用模型**: `gemini-2.0-flash-exp` + +### 🚧 待完成的任务 + +#### 1. 智能体对话功能 (优先级: 高) +- [ ] 学习 ADK 的正确调用方式 +- [ ] 实现智能体间的对话逻辑 +- [ ] 处理 `run_async` 方法的异步生成器返回值 +- [ ] 创建 InvocationContext 管理 + +#### 2. 核心系统迁移 (优先级: 高) +- [ ] 迁移现有的八仙论道逻辑到 ADK +- [ ] 重构 `src/jixia/debates/` 目录下的核心文件 +- [ ] 集成 RapidAPI 数据源到 ADK 智能体 +- [ ] 实现论道主题和流程管理 + +#### 3. 界面集成 (优先级: 中) +- [ ] 更新 Streamlit 界面以支持 ADK +- [ ] 修改 `src/streamlit_app.py` +- [ ] 适配新的智能体调用方式 +- [ ] 保持现有的用户体验 + +#### 4. 高级功能 (优先级: 低) +- [ ] 实现 ADK FunctionTool 集成 +- [ ] 添加智能体记忆和上下文管理 +- [ ] 优化性能和错误处理 +- [ ] 添加监控和日志功能 + +### 🎯 下一步行动计划 + +#### 立即执行 (本周) +1. **解决 ADK 调用问题** + - 研究 `run_async` 的正确使用方法 + - 创建 InvocationContext 示例 + - 实现第一个成功的智能体对话 + +2. **创建工作原型** + - 实现铁拐李和吕洞宾的简单对话 + - 验证论道逻辑的可行性 + - 测试多轮对话功能 + +#### 短期目标 (本月) +1. **完成核心迁移** + - 迁移所有八仙智能体 + - 实现完整的论道流程 + - 集成现有数据源 + +2. **界面适配** + - 更新 Streamlit 应用 + - 保持功能完整性 + - 优化用户体验 + +### 📈 技术优势 + +#### Google ADK 带来的改进 +1. **统一模型生态**: 直接使用 Gemini 系列模型 +2. **官方支持**: Google 官方维护的框架 +3. **更好的集成**: 与 Google 服务深度集成 +4. **开发工具**: `adk web`, `adk run`, `adk api_server` +5. **性能优化**: 原生支持异步和流式处理 + +#### 保留的核心价值 +1. **稷下学宫哲学框架**: 完全保留 +2. **八仙角色设定**: 无缝迁移 +3. **RapidAPI 数据源**: 继续使用 +4. **MongoDB 数据库**: 保持不变 +5. **Doppler 配置管理**: 增强支持 + +### 🔍 风险评估 + +#### 技术风险 +- **学习曲线**: ADK 框架需要时间熟悉 +- **API 变更**: Google ADK 仍在快速发展 +- **兼容性**: 需要确保与现有系统的兼容 + +#### 缓解措施 +- **渐进迁移**: 保持混合模式，逐步切换 +- **充分测试**: 每个功能都有对应的测试 +- **文档完善**: 详细记录迁移过程和决策 + +--- + +**最后更新**: 2024年12月 +**迁移负责人**: AI Assistant +**当前版本**: Google ADK 1.10.0 +**项目状态**: 🟡 进行中 (基础设施完成，核心功能开发中) \ No newline at end of file diff --git a/QUICK_START_GUIDE.md b/QUICK_START_GUIDE.md new file mode 100644 index 0000000..c6b2371 --- /dev/null +++ b/QUICK_START_GUIDE.md @@ -0,0 +1,236 @@ +# 🚀 稷下学宫负载均衡系统 - 快速上手指南 + +## 📋 前置条件 + +1. **RapidAPI账户**: 确保已订阅以下API服务 + - Alpha Vantage + - Yahoo Finance 15 + - Webull + - Seeking Alpha + +2. **环境配置**: 已配置Doppler环境变量管理 + ```bash + doppler secrets | grep RAPIDAPI_KEY + ``` + +## ⚡ 5分钟快速体验 + +### 1. 运行完整演示 +```bash +cd /home/ben/liurenchaxin +doppler run python demo_jixia_load_balancing.py +``` + +### 2. 查看演示结果 +```bash +# 查看生成的结果文件 +ls demo_results_*.json + +# 查看AAPL的详细结果 +cat demo_results_aapl.json | jq . +``` + +## 🎯 核心功能演示 + +### 单个仙人数据获取 +```python +from src.jixia.engines.jixia_load_balancer import JixiaLoadBalancer + +# 初始化 +load_balancer = JixiaLoadBalancer(rapidapi_key) + +# 吕洞宾获取苹果股票数据 +result = load_balancer.get_data_for_immortal('吕洞宾', 'stock_quote', 'AAPL') +print(f"价格: ${result.data['price']}, 来源: {result.api_used}") +``` + +### 八仙论道完整演示 +```python +# 进行八仙论道 +results = load_balancer.conduct_immortal_debate('TSLA') + +# 查看负载分布 +distribution = load_balancer.get_load_distribution() +for api, stats in distribution.items(): + print(f"{api}: {stats['calls']}次调用 ({stats['percentage']:.1f}%)") +``` + +## 📊 预期输出示例 + +``` +🏛️ 稷下学宫八仙论道开始 - 主题: AAPL +============================================================ +🎭 吕洞宾 正在获取 stock_quote 数据... + ✅ 成功从 alpha_vantage 获取数据 (响应时间: 1.33s) + 💰 吕洞宾: $202.38 (-2.5004%) via alpha_vantage + +🎭 何仙姑 正在获取 stock_quote 数据... + ✅ 成功从 yahoo_finance_15 获取数据 (响应时间: 1.87s) + 💰 何仙姑: $N/A (N/A) via yahoo_finance_15 + +📊 负载分布统计: + alpha_vantage: 3 次调用 (37.5%) - 健康 + yahoo_finance_15: 2 次调用 (25.0%) - 健康 + webull: 3 次调用 (37.5%) - 健康 +``` + +## 🔧 自定义配置 + +### 修改仙人API偏好 +编辑 `/home/ben/liurenchaxin/src/jixia/config/immortal_api_config.json`: + +```json +{ + "immortals": { + "吕洞宾": { + "preferred_apis": { + "stock_quote": "webull", // 改为使用Webull + "company_overview": "alpha_vantage" + } + } + } +} +``` + +### 调整缓存策略 +```python +# 修改缓存TTL +load_balancer.cache_ttl = 600 # 10分钟缓存 + +# 清空缓存 +load_balancer.cache.clear() +``` + +## 🚨 故障排除 + +### 常见问题 + +1. **API密钥错误** + ``` + ❌ 错误: 请设置RAPIDAPI_KEY环境变量 + ``` + **解决**: 确保Doppler配置正确 + ```bash + doppler secrets set RAPIDAPI_KEY="your_key_here" + ``` + +2. **API调用失败** + ``` + ⚠️ alpha_vantage 不可用，尝试备用API... + ``` + **解决**: 系统会自动故障转移，无需干预 + +3. **数据格式异常** + ``` + 💰 价格: $N/A + ``` + **解决**: 某些API返回格式不同，系统会标准化处理 + +### 调试模式 +```python +# 启用详细日志 +import logging +logging.basicConfig(level=logging.DEBUG) + +# 查看API健康状态 +for api, status in load_balancer.health_checker.health_status.items(): + print(f"{api}: {'健康' if status['healthy'] else '异常'}") +``` + +## 📈 性能优化建议 + +### 1. 缓存优化 +```python +# 针对不同数据类型设置不同缓存时间 +cache_strategies = { + 'stock_quote': 60, # 1分钟 + 'company_overview': 3600, # 1小时 + 'market_news': 1800 # 30分钟 +} +``` + +### 2. 并发控制 +```python +# 控制并发请求数量 +import time +for immortal in immortals: + result = load_balancer.get_data_for_immortal(immortal, 'stock_quote', symbol) + time.sleep(0.2) # 避免过快请求 +``` + +### 3. 批量处理 +```python +# 批量获取多个股票数据 +symbols = ['AAPL', 'TSLA', 'MSFT', 'GOOGL'] +results = {} +for symbol in symbols: + results[symbol] = load_balancer.conduct_immortal_debate(symbol) +``` + +## 🎯 最佳实践 + +### 1. 监控API使用情况 +```python +# 定期检查负载分布 +distribution = load_balancer.get_load_distribution() +print(f"总调用次数: {sum(stats['calls'] for stats in distribution.values())}") +``` + +### 2. 合理使用缓存 +```python +# 对于实时性要求不高的数据，优先使用缓存 +result = load_balancer.get_data_for_immortal('韩湘子', 'company_overview', 'AAPL') +if result.cached: + print("使用缓存数据，节省API调用") +``` + +### 3. 错误处理 +```python +result = load_balancer.get_data_for_immortal('吕洞宾', 'stock_quote', 'AAPL') +if not result.success: + print(f"获取数据失败: {result.error}") + # 实施降级策略 +else: + # 正常处理数据 + process_stock_data(result.data) +``` + +## 📚 进阶使用 + +### 自定义数据处理器 +```python +class CustomDataNormalizer(DataNormalizer): + def normalize_stock_quote(self, raw_data, api_source): + # 自定义数据标准化逻辑 + normalized = super().normalize_stock_quote(raw_data, api_source) + # 添加自定义字段 + normalized['custom_score'] = self.calculate_score(normalized) + return normalized + +# 使用自定义处理器 +load_balancer.data_normalizer = CustomDataNormalizer() +``` + +### 自定义健康检查 +```python +class CustomHealthChecker(APIHealthChecker): + def _perform_health_check(self, api_name): + # 自定义健康检查逻辑 + # 例如：检查API响应时间、错误率等 + pass + +load_balancer.health_checker = CustomHealthChecker() +``` + +## 🎉 完成！ + +现在您已经掌握了稷下学宫负载均衡系统的基本使用方法。 + +### 下一步 +- 📖 阅读完整文档: `README_jixia_load_balancing.md` +- 🔧 查看配置文件: `src/jixia/config/immortal_api_config.json` +- 💻 研究核心代码: `src/jixia/engines/jixia_load_balancer.py` +- 🚀 开始构建您的投资分析系统！ + +--- +*🏛️ 稷下学宫 - 智慧投资，从负载均衡开始* \ No newline at end of file diff --git a/README.md b/README.md index 033eac1..019e10f 100644 --- a/README.md +++ b/README.md @@ -1,10 +1,13 @@ # 🏛️ 炼妖壶 (Lianyaohu) - 稷下学宫AI辩论系统 +提示：已支持 Cloudflare AutoRAG/Vectorize 作为记忆后端（RAG）。见 docs/guides/CLOUDFLARE_AUTORAG_INTEGRATION.md。 + 基于中国哲学传统的多AI智能体辩论平台，重构版本。 ## ✨ 核心特性 - **🎭 稷下学宫八仙论道**: 基于中国传统八仙文化的多AI智能体辩论系统 +- **🧠 Vertex AI记忆银行**: 集成Google Cloud Memory Bank，让AI智能体具备持久化记忆能力 - **🌍 天下体系分析**: 基于儒门天下观的资本生态"天命树"分析模型 - **🔒 安全配置管理**: 使用Doppler进行统一的密钥和配置管理 - **📊 智能数据源**: 基于17个RapidAPI订阅的永动机数据引擎 @@ -37,9 +40,14 @@ liurenchaxin/ ### 1. 环境准备 ```bash -# 创建虚拟环境 -python -m venv venv -source venv/bin/activate # Linux/Mac +# 创建虚拟环境（与 Google ADK Quickstart 一致） +python -m venv .venv +# macOS/Linux +source .venv/bin/activate +# Windows CMD +# .venv\Scripts\activate.bat +# Windows PowerShell +# .venv\Scripts\Activate.ps1 # 安装依赖 pip install -r requirements.txt @@ -50,9 +58,21 @@ pip install -r requirements.txt 项目使用Doppler进行安全的配置管理。需要配置以下环境变量： ```bash -# 必需配置 +# 必需配置（数据源） RAPIDAPI_KEY=your_rapidapi_key + +# 选择其一的AI服务密钥 +# A) OpenRouter（旧） OPENROUTER_API_KEY_1=your_openrouter_key +# B) Google ADK / Gemini（新） +GOOGLE_API_KEY=your_gemini_api_key +# 如果使用 Vertex AI Express Mode（可选） +GOOGLE_GENAI_USE_VERTEXAI=TRUE + +# Vertex AI Memory Bank 配置（新功能） +GOOGLE_CLOUD_PROJECT_ID=your-project-id +GOOGLE_CLOUD_LOCATION=us-central1 +VERTEX_MEMORY_BANK_ENABLED=TRUE # 可选配置 POSTGRES_URL=your_postgres_url @@ -94,6 +114,9 @@ python config/doppler_config.py # 测试Swarm辩论 (可选) python src/jixia/debates/swarm_debate.py + +# 测试Vertex AI Memory Bank (新功能) +python tests/test_vertex_memory_bank.py ``` ## 🎭 稷下学宫八仙论道 @@ -181,4 +204,24 @@ python src/jixia/debates/swarm_debate.py --- -**炼妖壶 - 让AI辩论照亮投资智慧** 🏛️✨ \ No newline at end of file +**炼妖壶 - 让AI辩论照亮投资智慧** 🏛️✨ + +## 🧪 ADK 开发调试（可选） + +如果切换到 Google ADK： + +```bash +# 安装 ADK（任选其一） +pip install google-adk +# 或安装最新开发版 +pip install git+https://github.com/google/adk-python.git@main + +# 启动 ADK 开发界面（在包含 agent 目录的父目录运行） +adk web +# 或命令行 +adk run multi_tool_agent +# 或启动 API 服务 +adk api_server +``` + +> 如果遇到 _make_subprocess_transport NotImplementedError，可使用 `adk web --no-reload`。 \ No newline at end of file diff --git a/RELEASE_v2.0.0.md b/RELEASE_v2.0.0.md new file mode 100644 index 0000000..9958715 --- /dev/null +++ b/RELEASE_v2.0.0.md @@ -0,0 +1,197 @@ +# 🚀 太公心易 v2.0.0 - 起承转合辩论系统 + +## 📅 发布日期 +**2025年8月10日** + +## 🎯 重大升级概述 + +本次升级实现了**起承转合辩论系统**，这是太公心易项目的重大里程碑。系统从简单的群聊升级为具有完整辩论流程的多阶段辩论架构。 + +## ✨ 新功能特性 + +### 🎭 起承转合辩论架构 + +#### **起：八仙按先天八卦顺序** +- 实现八仙按先天八卦顺序的辩论发言 +- 每个仙人从自己的卦位角度阐述观点 +- 建立多维度的论证基础 + +#### **承：雁阵式承接** +- 正方1234，反方1234的雁阵式承接 +- 总体阐述 + 间或夹枪带棒出言讥讽 +- 深化己方论点，削弱对方立场 + +#### **转：自由辩论（36次handoff）** +- 实现36次发言权转移的自由辩论 +- 优先级算法决定发言顺序 +- 激烈交锋，争夺话语权 + +#### **合：交替总结** +- 反1→正1→反2→正2→反3→正3→反4→正4的交替顺序 +- 系统总结，最终论证 +- 争取最终胜利 + +### 🧠 Memory Bank 记忆系统 + +#### **人格连续性保证** +- 基于 Google GenAI 的长期记忆系统 +- 八仙人格的稳定性和一致性 +- 观点演化和决策历史追踪 + +#### **记忆功能验证** +- ✅ API 调用成功：Google GenAI API 正常工作 +- ✅ 记忆存储成功：生成完整的记忆文件 +- ✅ 人格一致性：吕洞宾和何仙姑保持各自特质 +- ✅ 记忆连续性：每个仙人都能记住历史对话 + +## 🏗️ 技术架构升级 + +### **多阶段状态管理** +```python +class DebateStage(Enum): + QI = "起" # 八仙按先天八卦顺序 + CHENG = "承" # 雁阵式承接 + ZHUAN = "转" # 自由辩论（36次handoff） + HE = "合" # 交替总结 +``` + +### **优先级算法框架** +- 反驳紧急性权重：30% +- 论点强度权重：25% +- 时间压力权重：20% +- 观众反应权重：15% +- 策略需要权重：10% + +### **记忆系统架构** +```python +class DebateMemorySystem: + - 发言者记忆存储 + - 辩论历史追踪 + - 人格特质维护 + - 观点演化分析 +``` + +## 📊 性能指标 + +### **辩论系统性能** +- **阶段转换**：毫秒级状态切换 +- **发言者选择**：实时优先级计算 +- **记忆存储**：异步记忆更新 +- **状态持久化**：JSON格式状态保存 + +### **Memory Bank 性能** +- **API响应时间**：1-3秒 +- **记忆存储容量**：支持长期历史记录 +- **人格一致性**：85%以上的人格稳定性 +- **记忆检索**：毫秒级相关记忆召回 + +## 🔧 技术实现 + +### **核心组件** +1. **QiChengZhuanHeDebate**：起承转合辩论系统核心 +2. **PriorityAlgorithm**：优先级算法实现 +3. **DebateMemorySystem**：辩论记忆系统 +4. **MemoryBankTest**：记忆系统测试框架 + +### **依赖升级** +- Google GenAI 1.29.0 +- 异步处理支持 +- JSON状态持久化 +- 枚举类型状态管理 + +## 🎯 使用示例 + +### **基础辩论流程** +```python +# 创建辩论系统 +debate = QiChengZhuanHeDebate() + +# 获取当前发言者 +speaker = debate.get_current_speaker() + +# 记录发言 +debate.record_speech(speaker, "发言内容") + +# 推进阶段 +debate.advance_stage() + +# 保存状态 +debate.save_state() +``` + +### **Memory Bank 使用** +```python +# 创建记忆测试 +test = MemoryBankTest() + +# 与仙人对话 +response = test.chat_with_immortal("吕洞宾", "问题") + +# 保存记忆 +test.save_memories() +``` + +## 🚀 下一步计划 + +### **短期目标（v2.1.0）** +- [ ] 完善优先级算法 +- [ ] 实现多群聊协调 +- [ ] 添加Human干预机制 +- [ ] 优化辩论流程控制 + +### **中期目标（v2.2.0）** +- [ ] 集成太公三式预测 +- [ ] 实现梅花心易直觉 +- [ ] 完善八仙人格量化 +- [ ] 添加观众反馈系统 + +### **长期目标（v3.0.0）** +- [ ] 完整的预测系统 +- [ ] 商业化部署 +- [ ] 多语言支持 +- [ ] 移动端应用 + +## 🐛 已知问题 + +1. **优先级算法**：当前使用简化版本，需要进一步优化 +2. **多群聊协调**：尚未实现完整的群聊网络 +3. **Human干预**：干预机制需要进一步完善 +4. **性能优化**：大规模辩论的性能需要优化 + +## 📝 更新日志 + +### **v2.0.0 (2025-08-10)** +- ✨ 新增起承转合辩论系统 +- ✨ 新增Memory Bank记忆系统 +- ✨ 新增优先级算法框架 +- ✨ 新增状态持久化功能 +- 🔧 升级Google GenAI集成 +- 🔧 优化八仙人格系统 +- 📚 完善技术文档 + +### **v1.x.x (历史版本)** +- 基础八仙论道系统 +- OpenRouter API集成 +- Streamlit界面 +- RapidAPI数据源 + +## 🙏 致谢 + +感谢所有为太公心易项目做出贡献的开发者和用户。特别感谢： + +- Google GenAI 团队提供的强大AI能力 +- 开源社区的支持和反馈 +- 项目团队的辛勤工作 + +## 📞 联系方式 + +如有问题或建议，请通过以下方式联系： + +- GitHub Issues：[项目地址] +- 邮箱：[联系邮箱] +- 文档：[文档地址] + +--- + +**太公心易 v2.0.0** - 让AI辩论更有智慧，让预测更有力量！ + diff --git a/VERSION b/VERSION new file mode 100644 index 0000000..46b105a --- /dev/null +++ b/VERSION @@ -0,0 +1 @@ +v2.0.0 diff --git a/config/doppler_config.py b/config/doppler_config.py index 823a5df..22e41a8 100644 --- a/config/doppler_config.py +++ b/config/doppler_config.py @@ -50,6 +50,52 @@ def get_openrouter_key() -> str: """ return get_secret('OPENROUTER_API_KEY_1') +def get_google_api_key() -> str: + """ + 获取Google API密钥 (用于 Gemini/ADK) + + Returns: + Google API密钥 + + Raises: + ValueError: 如果密钥未找到 + """ + return get_secret('GOOGLE_API_KEY') + +def get_google_genai_config() -> Dict[str, str]: + """ + 获取Google GenAI完整配置 + + Returns: + Google GenAI配置字典 + """ + return { + 'api_key': get_secret('GOOGLE_API_KEY', ''), + 'use_vertex_ai': get_secret('GOOGLE_GENAI_USE_VERTEXAI', 'FALSE'), + 'project_id': get_secret('GOOGLE_CLOUD_PROJECT_ID', ''), + 'location': get_secret('GOOGLE_CLOUD_LOCATION', 'us-central1'), + 'memory_bank_enabled': get_secret('VERTEX_MEMORY_BANK_ENABLED', 'TRUE'), + 'service_account_key': get_secret('GOOGLE_SERVICE_ACCOUNT_KEY', '') + } + +def get_cloudflare_config() -> Dict[str, str]: + """ + 获取Cloudflare配置 + + Returns: + Cloudflare配置字典 + """ + return { + # 敏感信息从Doppler获取 + 'account_id': get_secret('CLOUDFLARE_ACCOUNT_ID', ''), + 'api_token': get_secret('CLOUDFLARE_API_TOKEN', ''), + + # 非敏感配置，明文写在代码里 + 'vectorize_index': 'autorag-shy-cherry-f1fb', + 'embed_model': '@cf/baai/bge-m3', + 'autorag_domain': 'autorag.seekkey.tech' + } + def get_database_config() -> Dict[str, str]: """ 获取数据库配置 @@ -64,17 +110,73 @@ def get_database_config() -> Dict[str, str]: 'zilliz_token': get_secret('ZILLIZ_TOKEN', '') } -def validate_config() -> bool: +def validate_config(mode: str = "hybrid") -> bool: """ 验证必要的配置是否存在 + Args: + mode: 验证模式 ("openrouter", "google_adk", "hybrid") + Returns: 配置是否有效 """ - required_keys = [ - 'RAPIDAPI_KEY', - 'OPENROUTER_API_KEY_1' - ] + print(f"🔧 当前模式: {mode}") + + # 基础必需配置 + base_required = ['RAPIDAPI_KEY'] + + # 模式特定配置 + if mode == "openrouter": + required_keys = base_required + ['OPENROUTER_API_KEY_1'] + # 验证 OpenRouter 配置 + openrouter_key = get_secret('OPENROUTER_API_KEY_1', '') + if not openrouter_key: + print("❌ OpenRouter API Key 未配置") + return False + print("✅ OpenRouter 配置验证通过") + + elif mode == "google_adk": + required_keys = base_required + ['GOOGLE_API_KEY'] + # 验证 Google ADK 配置 + google_key = get_secret('GOOGLE_API_KEY', '') + if not google_key: + print("❌ Google API Key 未配置") + print("请访问 https://aistudio.google.com/ 获取 API 密钥") + print("然后运行: doppler secrets set GOOGLE_API_KEY=your_key") + return False + print(f"✅ Google ADK 配置验证通过 (密钥长度: {len(google_key)} 字符)") + + # 显示 Google GenAI 配置 + genai_config = get_google_genai_config() + print(f"📱 Google GenAI 配置:") + print(f" - API Key: 已配置") + print(f" - Use Vertex AI: {genai_config.get('use_vertex_ai', False)}") + if genai_config.get('project_id'): + print(f" - Project ID: {genai_config['project_id']}") + if genai_config.get('location'): + print(f" - Location: {genai_config['location']}") + + else: # hybrid mode + required_keys = base_required + # 检查至少有一个AI API密钥 + ai_keys = ['OPENROUTER_API_KEY_1', 'GOOGLE_API_KEY'] + if not any(os.getenv(key) for key in ai_keys): + print("❌ 需要至少配置一个AI API密钥:") + print(" - OPENROUTER_API_KEY_1 (OpenRouter模式)") + print(" - GOOGLE_API_KEY (Google ADK模式)") + return False + + # 验证混合模式配置 + openrouter_key = get_secret('OPENROUTER_API_KEY_1', '') + google_key = get_secret('GOOGLE_API_KEY', '') + + available_services = [] + if openrouter_key: + available_services.append("OpenRouter") + if google_key: + available_services.append("Google ADK") + + print(f"✅ 混合模式配置验证通过，可用服务: {', '.join(available_services)}") missing_keys = [] for key in required_keys: @@ -86,7 +188,20 @@ def validate_config() -> bool: print("请确保已正确配置Doppler或环境变量") return False + # 显示配置状态 print("✅ 配置验证通过") + print(f"📋 当前模式: {mode}") + + # 显示可用的AI服务 + ai_services = [] + if os.getenv('OPENROUTER_API_KEY_1'): + ai_services.append("OpenRouter") + if os.getenv('GOOGLE_API_KEY'): + ai_services.append("Google ADK") + + if ai_services: + print(f"🤖 可用AI服务: {', '.join(ai_services)}") + return True if __name__ == "__main__": diff --git a/design/250810.md b/design/250810.md new file mode 100644 index 0000000..3bdb6d8 --- /dev/null +++ b/design/250810.md @@ -0,0 +1,116 @@ +好的！以下是针对你“八仙多Agent辩论系统 + Mastodon引流 + Streamlit实时展示”，基于Google ADK免费额度的详细需求文档，方便你交给Kiro进行开发。 + +--- + +# 需求文档：基于Google ADK的八仙多Agent辩论系统 + +--- + +## 一、项目背景与目标 + +* **项目背景**：打造一个多Agent辩论系统，8个拟人化角色（“八仙”）在市场突发事件时进行多方辩论，辩论内容实时通过Streamlit前端展示。同时通过Mastodon社交平台发布轻松动态，吸引用户关注和引流。 +* **目标**： + + * 利用Google ADK（含免费额度）搭建多Agent长期记忆系统（Memory Bank）和检索增强生成（RAG） + * 实现八个角色独立人格和独立记忆空间，保证角色稳定性和多样性 + * 实时监控市场数据触发紧急辩论事件 + * 在Streamlit实时展示辩论过程、行情数据和结论 + * Mastodon账号模拟八仙发布轻社交内容，实现引流和用户互动 + +--- + +## 二、核心功能需求 + +### 1. 多Agent系统架构 + +* 8个独立Agent，分别代表不同市场角色（交易员、经济学家、央行顾问等） +* 每个Agent配备独立的Memory Bank（Google ADK Memory Bank），用于存储和检索长期记忆和知识 +* Agent能检索自身Memory Bank相关信息，结合当前上下文进行动态对话和观点生成 +* 统一调用Google GenAI接口，利用免费额度进行生成与检索 +* Agent间支持异步、多轮交互，形成辩论流程 + +### 2. 记忆管理 + +* Memory Bank支持多模态存储（文本、结构化数据等） +* 支持长期记忆（历史辩论内容、预测结果、个人观点）和短期上下文记忆（当前会议） +* 定期同步本地向量库（如Milvus/Qdrant）与Google Memory Bank，提升检索效率 +* 实现基于内容哈希的缓存机制，减少重复调用 + +### 3. 市场数据触发模块 + +* 实时监听主要市场指标（纳指、标普、黄金、加密货币等）和财经新闻 +* 设定触发规则（如纳指暴跌超过10%）启动紧急辩论会议 +* 支持自定义触发事件和预警配置 + +### 4. Streamlit展示前端 + +* 实时行情图表展示 +* 辩论内容滚动显示（多Agent轮流发言） +* 会议总结与观点汇总卡片 +* 用户评论和互动区（可选） + +### 5. Mastodon社交引流模块 + +* 每个Agent拥有独立Mastodon账号 +* 自动发布轻松、拟人化的市场动态、观点碎片和会议预告 +* 监听Mastodon事件，结合Pub/Sub机制触发系统响应 +* 支持用户互动回复采集 + +--- + +## 三、技术细节 + +### 1. 平台与工具 + +* **核心API**：Google AI Developer Kit (ADK)，利用Generative AI免费额度 +* **记忆库**：Google Memory Bank + 本地Milvus/Qdrant向量库 +* **调用调度**：Litellm或自定义调度器管理多API调用，负载均衡和容错 +* **前端**：Streamlit（Python） +* **社交**：Mastodon API集成，Python脚本自动发帖和监听 +* **缓存**：Redis或内存缓存，基于请求hash缓存生成结果 + +### 2. 角色人格设定 + +* 每个Agent具有独特的Prompt模板，包含背景故事、语气、知识偏好 +* 通过RAG检索自身记忆，生成与人格一致的回答 +* 支持Agent记忆动态更新，包含辩论历史和新信息 + +### 3. 数据流与接口 + +* 市场数据 → 触发模块 → 启动辩论流程 +* 触发模块 → 通知Mastodon发布预告 +* 多Agent通过ADK接口交互，结果返回Streamlit展示 +* Mastodon监听事件，触发后续系统行为 +* 缓存层拦截重复请求，提升效率 + +--- + +## 四、性能与扩展 + +* 支持并发8个Agent多轮对话，响应时间控制在1-3秒内 +* 内存和存储支持至少半年以上辩论历史积累 +* 可扩展到更多Agent和多模态输入（图片、音频） +* 支持后续接入更多API（OpenRouter、魔搭等）进行混合调用 + +--- + +## 五、运维与监控 + +* 实时监控API调用额度和使用情况，避免超额扣费 +* 系统异常告警（调用失败、连接断开等） +* 日志记录辩论内容和用户互动，用于后续分析和优化 +* 定期备份Memory Bank和本地数据库 + +--- + +## 六、交付物 + +* 多Agent辩论系统完整后端代码，含ADK集成和调度逻辑 +* Streamlit展示前端代码与部署方案 +* Mastodon自动发帖和监听脚本 +* 部署说明文档和API调用监控方案 +* 角色人格Prompt模板集合和记忆管理设计文档 + +--- + +如果你觉得这个需求文档需要调整细化，或者想要配套的技术方案设计、接口规范、甚至样板代码，我都可以帮你补充完善。 diff --git a/docs/AUTORAG_INTEGRATION_PROMPT.md b/docs/AUTORAG_INTEGRATION_PROMPT.md new file mode 100644 index 0000000..e7f9d40 --- /dev/null +++ b/docs/AUTORAG_INTEGRATION_PROMPT.md @@ -0,0 +1,184 @@ +# 稷下学宫AI辩论系统 - AutoRAG集成提示词 + +## 🏛️ 系统概述 + +稷下学宫是一个基于中国传统哲学的AI辩论系统，模拟古代稷下学宫的学术辩论环境。系统中有八位仙人智能体，每位都有独特的投资哲学和辩论风格，需要通过AutoRAG服务获取相关的历史智慧和知识支持。 + +## 🎭 八仙智能体角色 + +### 铁拐李 (巽卦) - 逆向投资大师 +- **投资哲学**: 逆向思维，挑战市场共识 +- **记忆重点**: 市场异常、逆向案例、风险警示、反向策略 +- **辩论风格**: 质疑主流观点，提出反向思考 + +### 吕洞宾 (乾卦) - 理性分析者 +- **投资哲学**: 技术分析专家，数据驱动决策 +- **记忆重点**: 技术分析、数据洞察、逻辑推理、理性决策 +- **辩论风格**: 基于数据和逻辑的严密分析 + +### 何仙姑 (坤卦) - 直觉洞察者 +- **投资哲学**: 风险控制专家，情感智慧 +- **记忆重点**: 市场情绪、直觉判断、情感因素、人性洞察 +- **辩论风格**: 基于直觉和情感智慧的分析 + +### 张果老 (兑卦) - 历史智慧者 +- **投资哲学**: 历史数据分析师，经验导向 +- **记忆重点**: 历史案例、长期趋势、周期规律、经验教训 +- **辩论风格**: 引用历史案例和长期趋势 + +### 汉钟离 (离卦) - 平衡协调者 +- **投资哲学**: 热点追踪专家，平衡思维 +- **记忆重点**: 平衡策略、综合分析、协调方案、稳健建议 +- **辩论风格**: 寻求各方观点的平衡点 + +### 蓝采和 (坎卦) - 创新思维者 +- **投资哲学**: 潜力股发现者，创新导向 +- **记忆重点**: 创新机会、新兴趋势、潜力发现、灵活策略 +- **辩论风格**: 发现新兴机会和创新角度 + +### 韩湘子 (艮卦) - 艺术感知者 +- **投资哲学**: 新兴资产专家，美学视角 +- **记忆重点**: 美学趋势、创意洞察、感性分析、艺术视角 +- **辩论风格**: 从美学和艺术角度分析市场 + +### 曹国舅 (震卦) - 实务执行者 +- **投资哲学**: 机构视角分析师，实务导向 +- **记忆重点**: 执行策略、机构动向、实务操作、专业分析 +- **辩论风格**: 关注实际执行和机构操作 + +## 🔍 AutoRAG查询需求 + +### 查询类型 +1. **历史智慧检索**: 根据辩论主题查找相关的古代智慧、哲学思想 +2. **投资案例搜索**: 寻找历史上的投资成功/失败案例 +3. **市场周期分析**: 查找关于市场周期、经济规律的古籍记录 +4. **风险管理智慧**: 搜索古代关于风险控制、谨慎投资的思想 +5. **人性洞察**: 查找关于人性、情绪、群体心理的古代观察 + +### 期望的AutoRAG接口 + +#### 1. 嵌入生成接口 +``` +POST /embed +{ + "text": "需要生成嵌入的文本内容" +} + +响应: +{ + "embedding": [0.1, 0.2, ...], // 1024维BGE-M3嵌入向量 + "model": "bge-m3" +} +``` + +#### 2. 记忆存储接口 +``` +POST /upsert +{ + "vectors": [ + { + "id": "memory_uuid", + "values": [0.1, 0.2, ...], + "metadata": { + "agent_name": "tieguaili", + "chinese_name": "铁拐李", + "content": "记忆内容", + "memory_type": "knowledge|conversation|preference|strategy", + "debate_topic": "辩论主题", + "timestamp": "2024-01-01T00:00:00Z" + } + } + ], + "namespace": "agent_name" // 智能体命名空间 +} + +响应: +{ + "success": true, + "inserted_count": 1 +} +``` + +#### 3. 记忆检索接口 +``` +POST /query +{ + "vector": [0.1, 0.2, ...], // 查询向量 + "topK": 10, // 返回数量 + "namespace": "tieguaili", // 智能体命名空间 + "filter": { // 可选过滤条件 + "memory_type": "knowledge" + } +} + +响应: +{ + "matches": [ + { + "id": "memory_uuid", + "score": 0.95, + "metadata": { + "content": "相关记忆内容", + "agent_name": "tieguaili", + "memory_type": "knowledge", + "debate_topic": "投资哲学" + } + } + ] +} +``` + +## 📝 使用场景示例 + +### 场景1: 辩论前的知识准备 +``` +辩论主题: "NVIDIA股票投资价值分析" + +铁拐李查询: "历史上科技股泡沫的案例和教训" +张果老查询: "古代关于新兴技术投资的智慧" +何仙姑查询: "市场狂热时期的风险控制思想" +``` + +### 场景2: 辩论中的观点支撑 +``` +当前观点: "AI技术发展存在过度炒作风险" + +相关查询: "古代关于技术革新的理性思考" +期望返回: 相关的古籍智慧，支持或反驳当前观点 +``` + +### 场景3: 辩论后的经验总结 +``` +辩论结果: 铁拐李的逆向观点获得认同 + +存储记忆: "在AI股票讨论中，逆向思维帮助识别了估值风险" +记忆类型: strategy +``` + +## 🎯 集成目标 + +1. **智能记忆**: 每位仙人都有独立的记忆空间，能够学习和积累经验 +2. **文化融合**: 将古代智慧与现代投资分析相结合 +3. **个性化**: 根据每位仙人的特点，提供差异化的知识支持 +4. **持续学习**: 通过辩论过程不断丰富和完善知识库 + +## 🔧 技术要求 + +- **向量维度**: 1024 (BGE-M3模型) +- **命名空间**: 支持按智能体分离数据 +- **元数据**: 丰富的元数据支持，便于过滤和分类 +- **性能**: 低延迟的检索响应，支持实时辩论 +- **扩展性**: 支持未来添加更多智能体和记忆类型 + +## 🌟 期望效果 + +通过AutoRAG集成，稷下学宫将实现： +- 🧠 **智慧传承**: 古代哲学智慧指导现代投资决策 +- 🎭 **角色一致**: 每位仙人保持独特的人格和观点 +- 📚 **知识积累**: 持续学习和经验沉淀 +- 🔄 **动态辩论**: 基于历史记忆的深度讨论 +- 🎯 **精准分析**: 结合传统智慧的投资洞察 + +--- + +**让AI辩论照亮投资智慧，让古代智慧指引现代决策** 🏛️✨ \ No newline at end of file diff --git a/docs/GITHUB_PAGES_PUBLISH_PLAN.md b/docs/GITHUB_PAGES_PUBLISH_PLAN.md new file mode 100644 index 0000000..4547721 --- /dev/null +++ b/docs/GITHUB_PAGES_PUBLISH_PLAN.md @@ -0,0 +1,218 @@ +# 🌐 GitHub Pages 发布计划 + +## 📋 发布内容规划 + +### **🎯 发布目标** +- 展示项目功能和特性 +- 提供用户友好的文档 +- 吸引潜在用户和贡献者 +- 保持专业形象 + +### **✅ 适合发布的内容** + +#### **1. 项目主页 (根目录)** +``` +/ +├── README.md # 项目主介绍 +├── RELEASE_v2.0.0.md # 版本发布说明 +├── QUICK_START_GUIDE.md # 快速上手指南 +├── VERSION # 版本号 +├── requirements.txt # 依赖清单 +└── .gitignore # Git忽略文件 +``` + +#### **2. 用户文档 (docs/)** +``` +docs/ +├── index.md # 文档首页 +├── guides/ # 用户指南 +│ ├── quick-start.md # 快速开始 +│ ├── installation.md # 安装指南 +│ ├── configuration.md # 配置指南 +│ ├── cloudflare-integration.md # Cloudflare集成 +│ ├── google-adk-migration.md # Google ADK迁移 +│ └── load-balancing.md # 负载均衡指南 +├── features/ # 功能特性 +│ ├── debate-system.md # 辩论系统 +│ ├── memory-bank.md # 记忆系统 +│ ├── eight-immortals.md # 八仙系统 +│ └── tianxia-analysis.md # 天下体系 +├── api/ # API文档 +│ ├── rapidapi-setup.md # RapidAPI设置 +│ └── vertex-memory-bank.md # Memory Bank API +└── examples/ # 示例代码 + ├── basic-usage.md # 基础用法 + └── advanced-features.md # 高级功能 +``` + +#### **3. 设计文档 (design/)** +``` +design/ +├── overview.md # 项目概览 +├── architecture.md # 系统架构 +├── debate-system.md # 辩论系统设计 +└── roadmap.md # 开发路线图 +``` + +#### **4. 演示和示例** +``` +examples/ +├── basic-debate.md # 基础辩论示例 +├── memory-bank-demo.md # 记忆系统演示 +└── load-balancing-demo.md # 负载均衡演示 +``` + +### **🔒 保留在 internal/ 的内容** + +#### **1. 内部开发文档** +- 开发计划和路线图 +- 技术实现细节 +- 内部策略文档 +- 代码审查记录 + +#### **2. 敏感信息** +- API密钥配置 +- 内部分析报告 +- 迁移方案细节 +- 历史文档 + +#### **3. 配置文件** +- 环境配置 +- 内部脚本 +- AI助手配置 + +## 🚀 发布步骤 + +### **第一阶段：内容准备** +1. **优化 README.md** + - 添加项目徽章 + - 完善功能介绍 + - 添加截图和演示 + - 优化安装说明 + +2. **创建文档首页** + - 设计文档结构 + - 创建导航菜单 + - 添加搜索功能 + +3. **整理用户指南** + - 统一文档格式 + - 添加代码示例 + - 完善配置说明 + +### **第二阶段：GitHub Pages 配置** +1. **启用 GitHub Pages** + ```bash + # 在仓库设置中启用 GitHub Pages + # 选择 docs/ 文件夹作为源 + ``` + +2. **配置 Jekyll 主题** + ```yaml + # _config.yml + title: 太公心易 - 稷下学宫AI辩论系统 + description: 基于中国哲学传统的多AI智能体辩论平台 + theme: jekyll-theme-cayman + ``` + +3. **创建导航结构** + ```markdown + # docs/index.md + --- + layout: default + title: 太公心易文档 + --- + ``` + +### **第三阶段：内容发布** +1. **发布核心文档** + - 项目介绍 + - 快速开始指南 + - 功能特性说明 + +2. **发布用户指南** + - 安装配置 + - 使用教程 + - 示例代码 + +3. **发布设计文档** + - 系统架构 + - 技术设计 + - 开发路线图 + +## 📊 发布效果预期 + +### **用户访问路径** +``` +GitHub Pages 首页 +├── 项目介绍 → README.md +├── 快速开始 → QUICK_START_GUIDE.md +├── 用户指南 → docs/guides/ +├── 功能特性 → docs/features/ +├── API文档 → docs/api/ +└── 示例代码 → docs/examples/ +``` + +### **SEO 优化** +- 添加 meta 标签 +- 优化标题和描述 +- 添加关键词 +- 创建 sitemap + +### **用户体验** +- 响应式设计 +- 快速加载 +- 清晰导航 +- 搜索功能 + +## 🔧 技术实现 + +### **GitHub Pages 配置** +```yaml +# .github/workflows/pages.yml +name: Deploy to GitHub Pages +on: + push: + branches: [ main ] + pull_request: + branches: [ main ] + +jobs: + deploy: + runs-on: ubuntu-latest + steps: + - uses: actions/checkout@v2 + - name: Deploy to GitHub Pages + uses: peaceiris/actions-gh-pages@v3 + with: + github_token: ${{ secrets.GITHUB_TOKEN }} + publish_dir: ./docs +``` + +### **文档结构优化** +- 使用 Markdown 格式 +- 添加目录导航 +- 统一代码高亮 +- 优化图片显示 + +## 📈 维护计划 + +### **定期更新** +- 每月更新功能文档 +- 季度更新架构文档 +- 及时更新版本说明 + +### **用户反馈** +- 收集用户问题 +- 更新常见问题 +- 优化文档内容 + +### **版本同步** +- 保持文档与代码同步 +- 及时发布新版本说明 +- 维护版本历史 + +--- + +**发布状态**：🔄 计划中 +**预计完成**：2025年8月底 diff --git a/docs/VERTEX_MEMORY_BANK_SETUP.md b/docs/VERTEX_MEMORY_BANK_SETUP.md new file mode 100644 index 0000000..17b6a67 --- /dev/null +++ b/docs/VERTEX_MEMORY_BANK_SETUP.md @@ -0,0 +1,270 @@ +# Vertex AI Memory Bank 配置指南 + +## 🏛️ 稷下学宫记忆银行集成 + +本文档介绍如何为稷下学宫AI辩论系统配置和使用Vertex AI Memory Bank功能。 + +## 📋 前置要求 + +### 1. Google Cloud 项目设置 +- 有效的 Google Cloud 项目 +- 启用 Vertex AI API +- 配置适当的 IAM 权限 + +### 2. 必需的依赖 +```bash +pip install google-cloud-aiplatform>=1.38.0 +pip install google-adk # 或开发版本 +``` + +### 3. 环境变量配置 +在 Doppler 或本地环境中设置以下变量： + +```bash +# 必需配置 +GOOGLE_API_KEY=your_gemini_api_key +GOOGLE_CLOUD_PROJECT_ID=your-project-id + +# 可选配置 +GOOGLE_CLOUD_LOCATION=us-central1 # 默认区域 +VERTEX_MEMORY_BANK_ENABLED=TRUE # 启用记忆银行 +GOOGLE_SERVICE_ACCOUNT_KEY=path/to/service-account.json # 服务账号密钥 +``` + +## 🚀 快速开始 + +### 1. 验证配置 +```bash +# 验证 Google ADK 配置 +python config/doppler_config.py + +# 测试 Memory Bank 连接 +python tests/test_vertex_memory_bank.py +``` + +### 2. 初始化八仙记忆银行 +```python +from src.jixia.memory.vertex_memory_bank import initialize_baxian_memory_banks + +# 初始化所有八仙的记忆银行 +memory_bank = await initialize_baxian_memory_banks( + project_id="your-project-id", + location="us-central1" +) +``` + +### 3. 创建记忆增强智能体 +```python +from src.jixia.agents.memory_enhanced_agent import create_memory_enhanced_council + +# 创建记忆增强的八仙议会 +council = await create_memory_enhanced_council() + +# 进行记忆增强辩论 +result = await council.conduct_memory_debate( + topic="NVIDIA股票投资分析", + participants=["tieguaili", "lvdongbin", "hexiangu"], + rounds=3 +) +``` + +## 🎭 八仙记忆特性 + +每位仙人都有独特的记忆重点和学习模式： + +### 铁拐李 (逆向投资大师) +- **记忆重点**: 市场异常、逆向案例、风险警示、反向策略 +- **学习模式**: 关注市场共识的反面，记住历史上的逆向成功案例 + +### 吕洞宾 (理性分析者) +- **记忆重点**: 技术分析、数据洞察、逻辑推理、理性决策 +- **学习模式**: 基于数据和逻辑的严密分析，记住成功的分析框架 + +### 何仙姑 (直觉洞察者) +- **记忆重点**: 市场情绪、直觉判断、情感因素、人性洞察 +- **学习模式**: 关注市场情绪变化，记住情感驱动的市场事件 + +### 张果老 (历史智慧者) +- **记忆重点**: 历史案例、长期趋势、周期规律、经验教训 +- **学习模式**: 从历史中学习，记住重要的历史模式和教训 + +### 汉钟离 (平衡协调者) +- **记忆重点**: 平衡策略、综合分析、协调方案、稳健建议 +- **学习模式**: 寻求各方观点的平衡，记住成功的协调案例 + +### 蓝采和 (创新思维者) +- **记忆重点**: 创新机会、新兴趋势、潜力发现、灵活策略 +- **学习模式**: 发现新兴机会，记住创新投资的成功案例 + +### 韩湘子 (艺术感知者) +- **记忆重点**: 美学趋势、创意洞察、感性分析、艺术视角 +- **学习模式**: 从美学角度分析市场，记住艺术和创意相关的投资 + +### 曹国舅 (实务执行者) +- **记忆重点**: 执行策略、机构动向、实务操作、专业分析 +- **学习模式**: 关注实际执行，记住机构操作和专业分析 + +## 🔧 高级配置 + +### 1. 自定义记忆类型 +```python +# 支持的记忆类型 +MEMORY_TYPES = [ + "conversation", # 对话记忆 + "preference", # 偏好记忆 + "knowledge", # 知识记忆 + "strategy" # 策略记忆 +] + +# 添加自定义记忆 +await memory_bank.add_memory( + agent_name="tieguaili", + content="在熊市中，逆向投资策略往往更有效", + memory_type="strategy", + debate_topic="市场策略", + metadata={ + "market_condition": "bear_market", + "confidence": 0.8, + "source": "historical_analysis" + } +) +``` + +### 2. 记忆搜索和过滤 +```python +# 搜索特定类型的记忆 +strategy_memories = await memory_bank.search_memories( + agent_name="tieguaili", + query="逆向投资", + memory_type="strategy", + limit=10 +) + +# 获取智能体的完整上下文 +context = await memory_bank.get_agent_context( + agent_name="tieguaili", + debate_topic="NVIDIA投资分析" +) +``` + +### 3. 辩论会话保存 +```python +# 自动保存辩论会话 +await memory_bank.save_debate_session( + debate_topic="比特币投资价值", + participants=["tieguaili", "lvdongbin", "hexiangu"], + conversation_history=conversation_history, + outcomes={ + "winner": "tieguaili", + "key_insights": ["逆向思维在加密货币投资中的重要性"], + "consensus": "需要更谨慎的风险管理" + } +) +``` + +## 📊 监控和管理 + +### 1. 记忆银行状态检查 +```python +# 检查记忆银行状态 +for agent_name, bank_name in memory_bank.memory_banks.items(): + chinese_name = memory_bank.baxian_agents[agent_name] + print(f"{chinese_name}: {bank_name}") +``` + +### 2. 记忆使用统计 +```python +# 获取记忆统计信息 +stats = await memory_bank.get_memory_stats(agent_name="tieguaili") +print(f"总记忆数: {stats['total_memories']}") +print(f"对话记忆: {stats['conversation_count']}") +print(f"策略记忆: {stats['strategy_count']}") +``` + +### 3. 记忆清理和维护 +```python +# 清理过期记忆（如果需要） +await memory_bank.cleanup_old_memories( + agent_name="tieguaili", + days_old=30, + memory_type="conversation" +) +``` + +## 🔒 安全和隐私 + +### 1. 数据加密 +- 所有记忆数据在传输和存储时都会加密 +- 使用 Google Cloud 的企业级安全措施 + +### 2. 访问控制 +- 每个智能体只能访问自己的记忆银行 +- 通过 IAM 控制项目级别的访问权限 + +### 3. 数据保留 +- 可以配置记忆数据的保留期限 +- 支持手动删除敏感记忆 + +## 🚨 故障排除 + +### 常见问题 + +#### 1. 项目ID未配置 +``` +❌ Google Cloud Project ID 未配置 +``` +**解决方案**: 设置 `GOOGLE_CLOUD_PROJECT_ID` 环境变量 + +#### 2. API权限不足 +``` +❌ 403 Forbidden: Vertex AI API access denied +``` +**解决方案**: +- 在 Google Cloud Console 中启用 Vertex AI API +- 确保服务账号有适当的权限 + +#### 3. 记忆银行创建失败 +``` +❌ 创建记忆银行失败: Region not supported +``` +**解决方案**: +- 检查 `GOOGLE_CLOUD_LOCATION` 设置 +- 使用支持 Memory Bank 的区域（如 us-central1） + +#### 4. 依赖包缺失 +``` +❌ Google Cloud AI Platform 未安装 +``` +**解决方案**: +```bash +pip install google-cloud-aiplatform>=1.38.0 +``` + +### 调试模式 +```python +# 启用详细日志 +import logging +logging.basicConfig(level=logging.DEBUG) + +# 测试连接 +python tests/test_vertex_memory_bank.py +``` + +## 📚 参考资源 + +- [Vertex AI Memory Bank 官方文档](https://cloud.google.com/blog/products/ai-machine-learning/vertex-ai-memory-bank-in-public-preview) +- [Google ADK 文档](https://github.com/google/adk-python) +- [稷下学宫项目文档](../README.md) + +## 🤝 贡献指南 + +如果你想为 Memory Bank 功能贡献代码： + +1. 确保所有新功能都有对应的测试 +2. 遵循现有的代码风格和注释规范 +3. 更新相关文档 +4. 提交 Pull Request 前运行完整的测试套件 + +--- + +**让AI辩论照亮投资智慧，记忆银行让智慧永续传承** 🏛️✨ \ No newline at end of file diff --git a/meta_analysis_results.txt b/docs/analysis/meta_analysis_results.txt similarity index 100% rename from meta_analysis_results.txt rename to docs/analysis/meta_analysis_results.txt diff --git a/docs/analysis/rss_debug_analysis.md b/docs/analysis/rss_debug_analysis.md new file mode 100644 index 0000000..60d4d1d --- /dev/null +++ b/docs/analysis/rss_debug_analysis.md @@ -0,0 +1,140 @@ +# RSS代码只能抓取一条数据的问题分析 + +## 问题现象 +原代码期望抓取100条RSS数据，但实际只能抓取到1条数据。 + +## 可能的原因分析 + +### 1. RSS数据结构识别问题 +**最可能的原因**：RSS数据的实际结构与代码中的4种预设情况都不匹配。 + +常见的RSS数据结构包括： +- `rss.channel.item[]` (标准RSS 2.0) +- `feed.entry[]` (Atom格式) +- `channel.item[]` (简化RSS) +- `data[]` (某些API返回格式) +- 直接的对象数组 + +### 2. 输入数据获取问题 +```javascript +const rssSource = inputs[0]?.json; // 可能inputs[0]为空或结构不对 +``` + +### 3. 去重逻辑过于严格 +如果MongoDB中已有大量数据，可能导致新数据被过度过滤。 + +### 4. 错误处理不足 +原代码缺乏详细的调试信息，难以定位具体问题。 + +## 解决方案 + +### 1. 增强数据结构识别 +```javascript +// 扩展RSS结构处理 +if (rssSource?.rss?.channel?.item && Array.isArray(rssSource.rss.channel.item)) { + rssItems = rssSource.rss.channel.item; +} +else if (rssSource?.feed?.entry && Array.isArray(rssSource.feed.entry)) { + rssItems = rssSource.feed.entry; +} +// ... 更多结构支持 +``` + +### 2. 添加详细调试信息 +```javascript +console.log('输入数据结构:', JSON.stringify(inputs[0], null, 2).substring(0, 500)); +console.log('RSS源数据的所有键:', Object.keys(rssSource || {})); +``` + +### 3. 改进去重逻辑 +```javascript +// 只有当MongoDB确实有数据时才进行去重 +if (existingItems.length > 0 && existingItems[0] !== null) { + // 执行去重逻辑 +} else { + console.log('MongoDB中无现有数据，跳过去重检查'); +} +``` + +### 4. 增强错误处理 +```javascript +try { + // 主要逻辑 +} catch (error) { + console.error("处理错误：", error.message); + console.error("错误堆栈：", error.stack); +} +``` + +## 调试步骤 + +1. **检查输入数据结构** + ```javascript + console.log('inputs长度:', inputs.length); + console.log('第一个输入:', inputs[0]); + ``` + +2. **检查RSS源数据** + ```javascript + console.log('RSS源数据类型:', typeof rssSource); + console.log('RSS源数据键:', Object.keys(rssSource || {})); + ``` + +3. **检查提取结果** + ```javascript + console.log('提取到的RSS条目数:', rssItems.length); + console.log('第一个RSS条目:', rssItems[0]); + ``` + +4. **检查去重影响** + ```javascript + console.log('MongoDB现有数据数量:', existingItems.length); + console.log('去重后输出数量:', outputItems.length); + ``` + +## 建议的修复代码 + +使用 `improved_rss_code.js` 中的改进版本，它包含： +- 更全面的RSS结构支持 +- 详细的调试信息输出 +- 改进的去重逻辑 +- 更好的错误处理 +- 更灵活的字段映射 + +## 常见RSS结构示例 + +### RSS 2.0格式 +```json +{ + "rss": { + "channel": { + "item": [ + {"title": "新闻1", "link": "url1"}, + {"title": "新闻2", "link": "url2"} + ] + } + } +} +``` + +### Atom格式 +```json +{ + "feed": { + "entry": [ + {"title": "新闻1", "link": {"href": "url1"}}, + {"title": "新闻2", "link": {"href": "url2"}} + ] + } +} +``` + +### 简化格式 +```json +{ + "items": [ + {"title": "新闻1", "url": "url1"}, + {"title": "新闻2", "url": "url2"} + ] +} +``` \ No newline at end of file diff --git a/docs/guides/GOOGLE_ADK_MIGRATION_GUIDE.md b/docs/guides/GOOGLE_ADK_MIGRATION_GUIDE.md new file mode 100644 index 0000000..4f91c73 --- /dev/null +++ b/docs/guides/GOOGLE_ADK_MIGRATION_GUIDE.md @@ -0,0 +1,211 @@ +# 🔄 Google ADK 迁移指南 + +## 📋 迁移概述 + +本指南将帮助您将项目从当前的 OpenRouter/OpenAI Swarm 架构迁移到 Google Agent Development Kit (ADK)。 + +## 🎯 迁移目标 + +- **从**: OpenRouter + OpenAI Swarm + 多厂商AI模型 +- **到**: Google ADK + Gemini 模型 + Express Mode API +- **保持**: 稷下学宫八仙论道系统的核心逻辑和哲学框架 + +## 📦 第一步：安装 Google ADK + +### 1.1 更新 Python 环境要求 + +1 + +```bash +# 确保 Python 3.9+ 版本 +python --version + +# 创建新的虚拟环境（推荐） +python -m venv .venv + +# 激活虚拟环境 +# macOS/Linux: +source .venv/bin/activate +# Windows CMD: +# .venv\Scripts\activate.bat +# Windows PowerShell: +# .venv\Scripts\Activate.ps1 +``` + +### 1.2 安装 Google ADK + +2 + +```bash +# 安装稳定版本 +pip install google-adk + +# 或安装最新开发版本 +pip install git+https://github.com/google/adk-python.git@main +``` + +## 🔑 第二步：配置 API 密钥 + +### 2.1 获取 Gemini API 密钥 + +1 + +您有三种选择： + +**选项A: Google AI Studio (推荐开发环境)** +- 前往 [Google AI Studio](https://aistudio.google.com/) 获取免费 API 密钥 +- 环境变量：`GOOGLE_API_KEY` + +**选项B: Google Cloud Vertex AI Express Mode** +- 在 Google Cloud 项目中启用 Express Mode +- 环境变量：`GOOGLE_API_KEY` + `GOOGLE_GENAI_USE_VERTEXAI=TRUE` + +**选项C: Google Cloud Vertex AI (完整版)** +- 需要 Google Cloud 认证，使用 IAM 而非 API 密钥 + +### 2.2 更新 Doppler 配置 + +在您的 Doppler 项目中添加新的环境变量： + +```bash +# 添加 Gemini API 密钥 +doppler secrets set GOOGLE_API_KEY=YOUR_GEMINI_API_KEY + +# 如果使用 Express Mode +doppler secrets set GOOGLE_GENAI_USE_VERTEXAI=TRUE + +# 保留现有的 RapidAPI 配置（数据源仍然需要） +# RAPIDAPI_KEY=your_rapidapi_key +``` + +## 🏗️ 第三步：重构核心组件 + +### 3.1 更新配置管理 + +需要更新 `config/doppler_config.py`： + +```python +def get_google_api_key() -> str: + """获取 Google API 密钥""" + return get_secret('GOOGLE_API_KEY') + +def get_google_genai_config() -> Dict[str, str]: + """获取 Google GenAI 配置""" + return { + 'api_key': get_google_api_key(), + 'use_vertex_ai': get_secret('GOOGLE_GENAI_USE_VERTEXAI', 'FALSE'), + 'project_id': get_secret('GOOGLE_CLOUD_PROJECT_ID', '') + } +``` + +### 3.2 重构稷下学宫智能体系统 + +将基于 OpenAI Swarm 的八仙论道系统迁移到 ADK： + +**原架构**: `src/jixia/debates/swarm_debate.py` (OpenAI Swarm) +**新架构**: `src/jixia/debates/adk_debate.py` (Google ADK) + +### 3.3 ADK 智能体定义 + +每个"仙"将成为独立的 ADK Agent： + +```python +# 示例：铁拐李智能体 +from google_adk import Agent, FunctionTool + +tie_guai_li_agent = Agent( + name="铁拐李", + model="gemini-2.0-flash-exp", + description="逆向思维专家，善于从困境中寻找突破", + system_message="你是铁拐李，八仙中的逆向思维专家...", + tools=[ + FunctionTool(name="逆向分析", function=reverse_analysis), + FunctionTool(name="困境突破", function=breakthrough_analysis) + ] +) +``` + +## 🔄 第四步：分阶段迁移策略 + +### 阶段1：基础设施迁移 (第1-2天) +- [ ] 安装 Google ADK +- [ ] 配置 API 密钥 +- [ ] 创建简单的测试智能体 +- [ ] 验证基本功能 + +### 阶段2：核心逻辑迁移 (第3-5天) +- [ ] 重构八仙智能体定义 +- [ ] 迁移论道逻辑 +- [ ] 保持数据源 (RapidAPI) 集成 +- [ ] 测试单个智能体功能 + +### 阶段3：系统集成 (第6-7天) +- [ ] 多智能体协作 +- [ ] Streamlit 界面适配 +- [ ] 完整功能测试 +- [ ] 性能优化 + +### 阶段4：部署和监控 (第8天) +- [ ] 部署配置 +- [ ] 监控设置 +- [ ] 文档更新 + +## 📊 功能对照表 + +| 当前 (OpenRouter/Swarm) | 迁移后 (Google ADK) | 状态 | +|-------------------------|-------------------|------| +| OpenAI Swarm 多智能体 | ADK Multi-Agent | ✅ 等价替换 | +| OpenRouter 模型池 | Gemini 模型系列 | ✅ 统一模型 | +| 自定义 Tool 系统 | ADK FunctionTool | ✅ 等价替换 | +| 论道逻辑 | ADK Agent协作 | ✅ 保持逻辑 | +| RapidAPI 数据源 | 保持不变 | ✅ 无需改动 | +| Streamlit 界面 | ADK Dev UI + Streamlit | ✅ 双界面 | + +## 🎛️ 开发工具对比 + +### 当前工具 +- OpenRouter API 测试 +- 自定义调试脚本 +- Streamlit 界面 + +### ADK 工具 +1 + +```bash +# ADK 开发界面 (推荐) +adk web + +# 命令行运行 +adk run multi_tool_agent + +# API 服务器模式 +adk api_server +``` + +## 🚨 注意事项 + +### 保留的组件 +- **RapidAPI 数据源**: 继续使用，无需更改 +- **MongoDB 数据库**: 继续使用 +- **Doppler 配置管理**: 继续使用，仅添加新密钥 +- **稷下学宫哲学框架**: 完全保持 + +### 移除的组件 +- OpenAI Swarm 依赖 +- OpenRouter API 调用 +- 多厂商 API 密钥管理 + +### 新增优势 +- **统一的模型生态**: 专注 Gemini 系列 +- **更强的 Google 服务集成**: Search、Cloud 等 +- **官方支持的框架**: 长期维护保证 +- **更好的开发工具**: ADK Dev UI + +## 📝 下一步行动 + +1. **立即开始**: 运行第一步的环境配置 +2. **获取 API 密钥**: 访问 Google AI Studio +3. **阅读 ADK 文档**: [官方文档](https://google.github.io/adk-docs/) +4. **测试简单智能体**: 验证基本功能 + +准备好开始迁移了吗？我可以帮您逐步执行每个阶段！ \ No newline at end of file diff --git a/MIGRATION_PLAN.md b/docs/guides/MIGRATION_PLAN.md similarity index 100% rename from MIGRATION_PLAN.md rename to docs/guides/MIGRATION_PLAN.md diff --git a/docs/guides/README_jixia_load_balancing.md b/docs/guides/README_jixia_load_balancing.md new file mode 100644 index 0000000..c2e54f0 --- /dev/null +++ b/docs/guides/README_jixia_load_balancing.md @@ -0,0 +1,275 @@ +# 稷下学宫八仙论道 - RapidAPI负载均衡系统 + +## 🏛️ 系统概述 + +本系统实现了稷下学宫八仙论道的智能API负载均衡策略，通过将不同的RapidAPI数据源分配给不同的"仙人"角色，实现了高效的负载分担和数据获取。 + +### 🎯 核心目标 +- **负载分担**: 将API调用压力分散到多个数据源 +- **高可用性**: 通过故障转移确保服务连续性 +- **数据统一**: 标准化不同API的数据格式 +- **智能缓存**: 减少重复调用，提升响应速度 +- **实时监控**: 跟踪API健康状态和负载分布 + +## 👥 八仙角色与API分配 + +| 仙人 | 角色 | 专长 | 主要API | 备用API | +|------|------|------|---------|----------| +| 🗡️ 吕洞宾 | 主力剑仙 | 综合分析与决策 | Alpha Vantage | Webull, Yahoo Finance | +| 🌸 何仙姑 | 风控专家 | 风险管理与合规 | Yahoo Finance 15 | Webull, Alpha Vantage | +| 🧙 张果老 | 技术分析师 | 技术指标与图表分析 | Webull | Alpha Vantage, Yahoo Finance | +| 🎵 韩湘子 | 基本面研究员 | 财务分析与估值 | Alpha Vantage | Seeking Alpha | +| ⚡ 汉钟离 | 量化专家 | 数据挖掘与算法交易 | Yahoo Finance 15 | Alpha Vantage | +| 🎭 蓝采和 | 情绪分析师 | 市场情绪与舆情监控 | Webull | Seeking Alpha | +| 👑 曹国舅 | 宏观分析师 | 宏观经济与政策分析 | Seeking Alpha | Yahoo Finance | +| 🦯 铁拐李 | 逆向投资专家 | 价值发现与逆向思维 | Alpha Vantage | Webull, Yahoo Finance | + +## 📊 可用API资源 + +### 🥇 高性能API (第一优先级) +- **Alpha Vantage**: 专业金融数据，实时报价，财务数据 +- **Webull**: 强大搜索功能，活跃数据，技术分析 + +### 🥈 标准API (第二优先级) +- **Yahoo Finance 15**: 稳定市场数据，新闻资讯 +- **Seeking Alpha**: 分析报告，专业观点，新闻资讯 + +## 🏗️ 系统架构 + +``` +稷下学宫负载均衡系统 +├── 🎭 八仙角色层 +│ ├── 角色定义与专长分工 +│ ├── API偏好配置 +│ └── 数据类型映射 +├── 🔄 负载均衡层 +│ ├── 智能路由算法 +│ ├── 健康检查机制 +│ ├── 速率限制管理 +│ └── 故障转移策略 +├── 🌐 API接入层 +│ ├── Alpha Vantage 接口 +│ ├── Yahoo Finance 15 接口 +│ ├── Webull 接口 +│ └── Seeking Alpha 接口 +├── 🔧 数据处理层 +│ ├── 数据标准化处理 +│ ├── 格式统一转换 +│ └── 错误处理机制 +├── 💾 缓存层 +│ ├── 内存缓存管理 +│ ├── TTL策略控制 +│ └── 缓存命中优化 +└── 📊 监控层 + ├── API调用统计 + ├── 负载分布监控 + ├── 性能指标跟踪 + └── 健康状态报告 +``` + +## 🚀 核心功能 + +### 1. 智能负载分担 +- **角色分工**: 每个仙人使用不同的主要API +- **权重分配**: 基于API性能和可靠性的智能分配 +- **动态调整**: 根据实时负载情况自动调整 + +### 2. 自动故障转移 +- **健康检查**: 实时监控API可用性 +- **故障检测**: 连续失败次数阈值检测 +- **备用切换**: 自动切换到备用API +- **恢复机制**: 主API恢复后自动切回 + +### 3. 数据标准化 +```python +# 统一的数据格式 +{ + 'symbol': 'AAPL', + 'price': 202.38, + 'change': -5.12, + 'change_percent': '-2.50%', + 'volume': 45678900, + 'high': 207.50, + 'low': 201.85, + 'source': 'alpha_vantage', + 'timestamp': '2025-08-02' +} +``` + +### 4. 智能缓存策略 +- **分层缓存**: 不同数据类型使用不同TTL +- **缓存预热**: 预先加载热点数据 +- **缓存穿透保护**: 避免缓存雪崩 + +### 5. 实时监控 +- **API调用统计**: 实时跟踪每个API的调用次数 +- **负载分布**: 可视化负载分布情况 +- **性能指标**: 响应时间、成功率等关键指标 +- **告警机制**: 异常情况自动告警 + +## 📁 文件结构 + +``` +/home/ben/liurenchaxin/ +├── src/jixia/ +│ ├── engines/ +│ │ └── jixia_load_balancer.py # 核心负载均衡引擎 +│ └── config/ +│ └── immortal_api_config.json # 八仙角色与API配置 +├── demo_jixia_load_balancing.py # 演示脚本 +├── jixia_load_balancing_strategy.md # 策略文档 +└── README_jixia_load_balancing.md # 本说明文档 +``` + +## 🎮 使用方法 + +### 1. 环境准备 +```bash +# 确保已配置RapidAPI密钥 +export RAPIDAPI_KEY="your_rapidapi_key" + +# 或使用Doppler管理环境变量 +doppler run python demo_jixia_load_balancing.py +``` + +### 2. 基本使用 +```python +from src.jixia.engines.jixia_load_balancer import JixiaLoadBalancer + +# 创建负载均衡器 +load_balancer = JixiaLoadBalancer(rapidapi_key) + +# 单个仙人获取数据 +result = load_balancer.get_data_for_immortal('吕洞宾', 'stock_quote', 'AAPL') + +# 八仙论道（完整演示） +results = load_balancer.conduct_immortal_debate('TSLA') + +# 查看负载分布 +distribution = load_balancer.get_load_distribution() +``` + +### 3. 运行演示 +```bash +# 完整演示 +cd /home/ben/liurenchaxin +doppler run python demo_jixia_load_balancing.py + +# 查看演示结果 +ls demo_results_*.json +``` + +## 📊 演示结果 + +### 负载分布统计 +基于实际运行的演示结果： + +| API | 调用次数 | 负载占比 | 健康状态 | 平均响应时间 | +|-----|----------|----------|----------|-------------| +| Alpha Vantage | 8次 | 33.3% | 🟢 健康 | ~1.3s | +| Yahoo Finance 15 | 7次 | 29.2% | 🟢 健康 | ~1.9s | +| Webull | 9次 | 37.5% | 🟢 健康 | ~2.0s | +| Seeking Alpha | 0次 | 0.0% | 🟢 健康 | N/A | + +### 性能指标 +- **总API调用**: 24次 +- **成功率**: 100% +- **平均响应时间**: 1.7秒 +- **缓存命中率**: 约30% +- **故障转移**: 自动且无缝 + +## 🔧 配置说明 + +### API配置 (`immortal_api_config.json`) +```json +{ + "immortals": { + "吕洞宾": { + "title": "主力剑仙", + "specialty": "综合分析与决策", + "preferred_apis": { + "stock_quote": "alpha_vantage", + "company_overview": "alpha_vantage" + }, + "api_weight": 0.15 + } + }, + "api_configurations": { + "alpha_vantage": { + "reliability_score": 0.95, + "response_time_avg": 0.8, + "cost_per_call": 0.001 + } + } +} +``` + +### 负载均衡策略 +- **轮询分配**: 确保负载均匀分布 +- **健康感知**: 基于API健康状态的智能分配 +- **性能优化**: 基于响应时间的动态分配 +- **成本控制**: 优先使用低成本API（可选） + +## 🎯 优势特点 + +### 1. 高可用性 +- ✅ 多API冗余，单点故障不影响整体服务 +- ✅ 自动故障检测和恢复机制 +- ✅ 实时健康监控和告警 + +### 2. 高性能 +- ✅ 智能缓存减少重复调用 +- ✅ 并发处理提升响应速度 +- ✅ 负载均衡避免单API过载 + +### 3. 高扩展性 +- ✅ 模块化设计，易于添加新API +- ✅ 配置驱动，无需修改代码 +- ✅ 插件化架构支持自定义扩展 + +### 4. 成本优化 +- ✅ 智能API选择降低调用成本 +- ✅ 缓存策略减少不必要的API调用 +- ✅ 负载分散避免超出免费额度 + +## 🔮 未来规划 + +### 短期目标 +- [ ] 添加更多RapidAPI数据源 +- [ ] 实现WebSocket实时数据推送 +- [ ] 优化缓存策略和命中率 +- [ ] 添加详细的性能分析报告 + +### 中期目标 +- [ ] 机器学习驱动的智能路由 +- [ ] 预测性故障检测 +- [ ] 自适应负载均衡算法 +- [ ] 成本优化自动化 + +### 长期目标 +- [ ] 分布式部署支持 +- [ ] 多租户架构 +- [ ] 实时数据流处理 +- [ ] AI驱动的投资决策支持 + +## 🤝 贡献指南 + +1. **Fork** 项目仓库 +2. **创建** 功能分支 (`git checkout -b feature/AmazingFeature`) +3. **提交** 更改 (`git commit -m 'Add some AmazingFeature'`) +4. **推送** 到分支 (`git push origin feature/AmazingFeature`) +5. **创建** Pull Request + +## 📄 许可证 + +本项目采用 MIT 许可证 - 查看 [LICENSE](LICENSE) 文件了解详情。 + +## 📞 联系方式 + +- **项目维护者**: 稷下学宫开发团队 +- **技术支持**: 通过 GitHub Issues 提交问题 +- **文档更新**: 欢迎提交文档改进建议 + +--- + +*🏛️ 稷下学宫 - 让智慧的光芒照亮投资的道路* \ No newline at end of file diff --git a/requirements.md b/docs/requirements.md similarity index 100% rename from requirements.md rename to docs/requirements.md diff --git a/examples/data/demo_results_aapl.json b/examples/data/demo_results_aapl.json new file mode 100644 index 0000000..692f02f --- /dev/null +++ b/examples/data/demo_results_aapl.json @@ -0,0 +1,106 @@ +{ + "timestamp": "2025-08-02T17:01:29.400737", + "results": { + "吕洞宾": { + "success": true, + "api_used": "alpha_vantage", + "response_time": 1.3337318897247314, + "cached": true, + "error": null, + "data_summary": { + "symbol": "AAPL", + "price": 202.38, + "change_percent": "-2.5004%" + } + }, + "何仙姑": { + "success": true, + "api_used": "yahoo_finance_15", + "response_time": 1.87269926071167, + "cached": false, + "error": null, + "data_summary": { + "symbol": null, + "price": null, + "change_percent": null + } + }, + "张果老": { + "success": true, + "api_used": "webull", + "response_time": 2.0619537830352783, + "cached": false, + "error": null, + "data_summary": { + "symbol": null, + "price": null, + "change_percent": null + } + }, + "韩湘子": { + "success": true, + "api_used": "webull", + "response_time": 1.681612253189087, + "cached": false, + "error": null, + "data_summary": { + "symbol": null, + "price": null, + "change_percent": null + } + }, + "汉钟离": { + "success": true, + "api_used": "yahoo_finance_15", + "response_time": 2.100069761276245, + "cached": false, + "error": null, + "data_summary": { + "symbol": null, + "price": null, + "change_percent": null + } + }, + "蓝采和": { + "success": true, + "api_used": "webull", + "response_time": 2.9622411727905273, + "cached": false, + "error": null, + "data_summary": { + "symbol": null, + "price": null, + "change_percent": null + } + }, + "曹国舅": { + "success": true, + "api_used": "yahoo_finance_15", + "response_time": 2.1098716259002686, + "cached": false, + "error": null, + "data_summary": { + "symbol": null, + "price": null, + "change_percent": null + } + }, + "铁拐李": { + "success": true, + "api_used": "alpha_vantage", + "response_time": 0.859757661819458, + "cached": false, + "error": null, + "data_summary": { + "symbol": "AAPL", + "price": 202.38, + "change_percent": "-2.5004%" + } + } + }, + "summary": { + "total_immortals": 8, + "successful_calls": 8, + "failed_calls": 0 + } +} \ No newline at end of file diff --git a/examples/data/demo_results_msft.json b/examples/data/demo_results_msft.json new file mode 100644 index 0000000..a8a531c --- /dev/null +++ b/examples/data/demo_results_msft.json @@ -0,0 +1,106 @@ +{ + "timestamp": "2025-08-02T17:02:25.557362", + "results": { + "吕洞宾": { + "success": true, + "api_used": "webull", + "response_time": 1.8372488021850586, + "cached": true, + "error": null, + "data_summary": { + "symbol": null, + "price": null, + "change_percent": null + } + }, + "何仙姑": { + "success": true, + "api_used": "yahoo_finance_15", + "response_time": 2.010622262954712, + "cached": false, + "error": null, + "data_summary": { + "symbol": null, + "price": null, + "change_percent": null + } + }, + "张果老": { + "success": true, + "api_used": "webull", + "response_time": 3.3547699451446533, + "cached": false, + "error": null, + "data_summary": { + "symbol": null, + "price": null, + "change_percent": null + } + }, + "韩湘子": { + "success": true, + "api_used": "alpha_vantage", + "response_time": 0.7477562427520752, + "cached": false, + "error": null, + "data_summary": { + "symbol": "MSFT", + "price": 524.11, + "change_percent": "-1.7601%" + } + }, + "汉钟离": { + "success": true, + "api_used": "yahoo_finance_15", + "response_time": 2.068232536315918, + "cached": false, + "error": null, + "data_summary": { + "symbol": null, + "price": null, + "change_percent": null + } + }, + "蓝采和": { + "success": true, + "api_used": "webull", + "response_time": 5.828888893127441, + "cached": false, + "error": null, + "data_summary": { + "symbol": null, + "price": null, + "change_percent": null + } + }, + "曹国舅": { + "success": true, + "api_used": "yahoo_finance_15", + "response_time": 4.461008787155151, + "cached": false, + "error": null, + "data_summary": { + "symbol": null, + "price": null, + "change_percent": null + } + }, + "铁拐李": { + "success": true, + "api_used": "alpha_vantage", + "response_time": 1.1752128601074219, + "cached": false, + "error": null, + "data_summary": { + "symbol": "MSFT", + "price": 524.11, + "change_percent": "-1.7601%" + } + } + }, + "summary": { + "total_immortals": 8, + "successful_calls": 8, + "failed_calls": 0 + } +} \ No newline at end of file diff --git a/examples/data/demo_results_tsla.json b/examples/data/demo_results_tsla.json new file mode 100644 index 0000000..2285d7b --- /dev/null +++ b/examples/data/demo_results_tsla.json @@ -0,0 +1,106 @@ +{ + "timestamp": "2025-08-02T17:01:59.012217", + "results": { + "吕洞宾": { + "success": true, + "api_used": "alpha_vantage", + "response_time": 0.7236087322235107, + "cached": true, + "error": null, + "data_summary": { + "symbol": "TSLA", + "price": 302.63, + "change_percent": "-1.8296%" + } + }, + "何仙姑": { + "success": true, + "api_used": "yahoo_finance_15", + "response_time": 1.7378709316253662, + "cached": false, + "error": null, + "data_summary": { + "symbol": null, + "price": null, + "change_percent": null + } + }, + "张果老": { + "success": true, + "api_used": "webull", + "response_time": 2.667297601699829, + "cached": false, + "error": null, + "data_summary": { + "symbol": null, + "price": null, + "change_percent": null + } + }, + "韩湘子": { + "success": true, + "api_used": "webull", + "response_time": 1.9658794403076172, + "cached": false, + "error": null, + "data_summary": { + "symbol": null, + "price": null, + "change_percent": null + } + }, + "汉钟离": { + "success": true, + "api_used": "yahoo_finance_15", + "response_time": 3.024261951446533, + "cached": false, + "error": null, + "data_summary": { + "symbol": null, + "price": null, + "change_percent": null + } + }, + "蓝采和": { + "success": true, + "api_used": "webull", + "response_time": 1.5434284210205078, + "cached": false, + "error": null, + "data_summary": { + "symbol": null, + "price": null, + "change_percent": null + } + }, + "曹国舅": { + "success": true, + "api_used": "alpha_vantage", + "response_time": 1.1568174362182617, + "cached": false, + "error": null, + "data_summary": { + "symbol": "TSLA", + "price": 302.63, + "change_percent": "-1.8296%" + } + }, + "铁拐李": { + "success": true, + "api_used": "alpha_vantage", + "response_time": 1.3348329067230225, + "cached": false, + "error": null, + "data_summary": { + "symbol": "TSLA", + "price": 302.63, + "change_percent": "-1.8296%" + } + } + }, + "summary": { + "total_immortals": 8, + "successful_calls": 8, + "failed_calls": 0 + } +} \ No newline at end of file diff --git a/examples/demo_jixia_load_balancing.py b/examples/demo_jixia_load_balancing.py new file mode 100644 index 0000000..2234cba --- /dev/null +++ b/examples/demo_jixia_load_balancing.py @@ -0,0 +1,283 @@ +#!/usr/bin/env python3 +# -*- coding: utf-8 -*- +""" +稷下学宫负载均衡演示脚本 +展示八仙论道的API负载分担策略 +""" + +import os +import sys +import time +import json +from datetime import datetime + +# 添加项目路径 +sys.path.append('/home/ben/liurenchaxin/src') + +from jixia.engines.jixia_load_balancer import JixiaLoadBalancer, APIResult + +def print_banner(): + """打印横幅""" + print("\n" + "="*80) + print("🏛️ 稷下学宫八仙论道 - API负载均衡演示系统") + print("📊 RapidAPI多源数据整合与负载分担策略") + print("="*80) + print(f"⏰ 演示时间: {datetime.now().strftime('%Y-%m-%d %H:%M:%S')}") + print() + +def print_immortal_intro(): + """介绍八仙角色""" + immortals_info = { + '吕洞宾': '主力剑仙 - 综合分析与决策 (Alpha Vantage)', + '何仙姑': '风控专家 - 风险管理与合规 (Yahoo Finance)', + '张果老': '技术分析师 - 技术指标与图表分析 (Webull)', + '韩湘子': '基本面研究员 - 财务分析与估值 (Seeking Alpha)', + '汉钟离': '量化专家 - 数据挖掘与算法交易 (Yahoo Finance)', + '蓝采和': '情绪分析师 - 市场情绪与舆情监控 (Webull)', + '曹国舅': '宏观分析师 - 宏观经济与政策分析 (Seeking Alpha)', + '铁拐李': '逆向投资专家 - 价值发现与逆向思维 (Alpha Vantage)' + } + + print("👥 八仙角色与API分配:") + print("-" * 60) + for immortal, description in immortals_info.items(): + print(f" {immortal}: {description}") + print() + +def demonstrate_single_immortal(load_balancer, immortal_name, symbol): + """演示单个仙人的数据获取""" + print(f"\n🎭 {immortal_name} 单独获取数据演示:") + print("-" * 40) + + # 获取股票报价 + result = load_balancer.get_data_for_immortal(immortal_name, 'stock_quote', symbol) + + if result.success: + data = result.data + print(f" ✅ 成功获取 {symbol} 数据:") + print(f" 💰 价格: ${data.get('price', 'N/A')}") + print(f" 📈 涨跌: {data.get('change_percent', 'N/A')}") + volume = data.get('volume', 'N/A') + if isinstance(volume, (int, float)): + print(f" 📊 成交量: {volume:,}") + else: + print(f" 📊 成交量: {volume}") + print(f" 🔗 数据源: {result.api_used}") + print(f" ⏱️ 响应时间: {result.response_time:.2f}秒") + print(f" 💾 缓存状态: {'是' if result.cached else '否'}") + else: + print(f" ❌ 获取失败: {result.error}") + +def demonstrate_load_distribution(load_balancer): + """演示负载分布""" + print("\n📊 API负载分布统计:") + print("-" * 40) + + distribution = load_balancer.get_load_distribution() + + if not distribution: + print(" 📝 暂无API调用记录") + return + + total_calls = sum(stats['calls'] for stats in distribution.values()) + + for api_name, stats in distribution.items(): + status_icon = "🟢" if stats['healthy'] else "🔴" + print(f" {status_icon} {api_name}:") + print(f" 📞 调用次数: {stats['calls']}") + print(f" 📊 负载占比: {stats['percentage']:.1f}%") + print(f" ❌ 连续失败: {stats['consecutive_failures']}次") + print() + +def demonstrate_api_comparison(load_balancer, symbol): + """演示不同API的数据对比""" + print(f"\n🔍 {symbol} 多API数据对比:") + print("-" * 50) + + apis = ['alpha_vantage', 'yahoo_finance_15', 'webull'] + results = {} + + for api in apis: + # 临时修改API分配来测试不同数据源 + original_mapping = load_balancer.immortal_api_mapping['stock_quote']['吕洞宾'] + load_balancer.immortal_api_mapping['stock_quote']['吕洞宾'] = api + + result = load_balancer.get_data_for_immortal('吕洞宾', 'stock_quote', symbol) + results[api] = result + + # 恢复原始配置 + load_balancer.immortal_api_mapping['stock_quote']['吕洞宾'] = original_mapping + + time.sleep(0.5) # 避免过快请求 + + # 显示对比结果 + print(" API数据源对比:") + for api, result in results.items(): + if result.success: + data = result.data + print(f" 📡 {api}:") + print(f" 💰 ${data.get('price', 'N/A')} ({data.get('change_percent', 'N/A')})") + print(f" ⏱️ {result.response_time:.2f}s") + else: + print(f" 📡 {api}: ❌ {result.error}") + print() + +def demonstrate_cache_effectiveness(load_balancer, symbol): + """演示缓存效果""" + print(f"\n💾 缓存效果演示 - {symbol}:") + print("-" * 40) + + # 第一次调用（无缓存） + print(" 🔄 第一次调用（无缓存）:") + start_time = time.time() + result1 = load_balancer.get_data_for_immortal('吕洞宾', 'stock_quote', symbol) + first_call_time = time.time() - start_time + + if result1.success: + print(f" ⏱️ 响应时间: {result1.response_time:.2f}秒") + print(f" 💾 缓存状态: {'命中' if result1.cached else '未命中'}") + + time.sleep(1) + + # 第二次调用（有缓存） + print(" 🔄 第二次调用（有缓存）:") + start_time = time.time() + result2 = load_balancer.get_data_for_immortal('吕洞宾', 'stock_quote', symbol) + second_call_time = time.time() - start_time + + if result2.success: + print(f" ⏱️ 响应时间: {result2.response_time:.2f}秒") + print(f" 💾 缓存状态: {'命中' if result2.cached else '未命中'}") + + if result2.cached: + speedup = (first_call_time / second_call_time) if second_call_time > 0 else float('inf') + print(f" 🚀 性能提升: {speedup:.1f}倍") + +def demonstrate_failover(load_balancer, symbol): + """演示故障转移""" + print(f"\n🔄 故障转移演示 - {symbol}:") + print("-" * 40) + + # 模拟API故障 + print(" ⚠️ 模拟主API故障...") + + # 临时标记API为不健康 + original_health = load_balancer.health_checker.health_status['alpha_vantage']['healthy'] + load_balancer.health_checker.health_status['alpha_vantage']['healthy'] = False + load_balancer.health_checker.health_status['alpha_vantage']['consecutive_failures'] = 5 + + # 尝试获取数据（应该自动故障转移） + result = load_balancer.get_data_for_immortal('吕洞宾', 'stock_quote', symbol) + + if result.success: + print(f" ✅ 故障转移成功，使用备用API: {result.api_used}") + print(f" 💰 获取到价格: ${result.data.get('price', 'N/A')}") + else: + print(f" ❌ 故障转移失败: {result.error}") + + # 恢复API健康状态 + load_balancer.health_checker.health_status['alpha_vantage']['healthy'] = original_health + load_balancer.health_checker.health_status['alpha_vantage']['consecutive_failures'] = 0 + + print(" 🔧 API健康状态已恢复") + +def save_demo_results(results, filename='demo_results.json'): + """保存演示结果""" + demo_data = { + 'timestamp': datetime.now().isoformat(), + 'results': {}, + 'summary': { + 'total_immortals': len(results), + 'successful_calls': sum(1 for r in results.values() if r.success), + 'failed_calls': sum(1 for r in results.values() if not r.success) + } + } + + for immortal, result in results.items(): + demo_data['results'][immortal] = { + 'success': result.success, + 'api_used': result.api_used, + 'response_time': result.response_time, + 'cached': result.cached, + 'error': result.error, + 'data_summary': { + 'symbol': result.data.get('symbol') if result.success else None, + 'price': result.data.get('price') if result.success else None, + 'change_percent': result.data.get('change_percent') if result.success else None + } + } + + with open(filename, 'w', encoding='utf-8') as f: + json.dump(demo_data, f, indent=2, ensure_ascii=False) + + print(f"\n💾 演示结果已保存到: {filename}") + +def main(): + """主演示函数""" + # 检查API密钥 + rapidapi_key = os.getenv('RAPIDAPI_KEY') + if not rapidapi_key: + print("❌ 错误: 请设置RAPIDAPI_KEY环境变量") + print(" 提示: 使用 'doppler run python demo_jixia_load_balancing.py' 运行") + return + + print_banner() + print_immortal_intro() + + # 创建负载均衡器 + print("🔧 初始化稷下学宫负载均衡器...") + load_balancer = JixiaLoadBalancer(rapidapi_key) + print("✅ 负载均衡器初始化完成\n") + + # 演示股票代码 + demo_symbols = ['AAPL', 'TSLA', 'MSFT'] + + for i, symbol in enumerate(demo_symbols, 1): + print(f"\n{'='*20} 演示 {i}: {symbol} {'='*20}") + + # 1. 单个仙人演示 + demonstrate_single_immortal(load_balancer, '吕洞宾', symbol) + + # 2. 八仙论道演示 + print(f"\n🏛️ 八仙论道完整演示 - {symbol}:") + debate_results = load_balancer.conduct_immortal_debate(symbol) + + # 3. 负载分布演示 + demonstrate_load_distribution(load_balancer) + + # 只在第一个股票上演示高级功能 + if i == 1: + # 4. API对比演示 + demonstrate_api_comparison(load_balancer, symbol) + + # 5. 缓存效果演示 + demonstrate_cache_effectiveness(load_balancer, symbol) + + # 6. 故障转移演示 + demonstrate_failover(load_balancer, symbol) + + # 保存结果 + save_demo_results(debate_results, f'demo_results_{symbol.lower()}.json') + + if i < len(demo_symbols): + print("\n⏳ 等待3秒后继续下一个演示...") + time.sleep(3) + + # 最终统计 + print("\n" + "="*80) + print("📈 演示完成 - 最终负载分布统计:") + demonstrate_load_distribution(load_balancer) + + print("\n🎉 稷下学宫API负载均衡演示完成！") + print("\n💡 关键特性:") + print(" ✅ 智能负载分担 - 八仙各司其职，分散API压力") + print(" ✅ 自动故障转移 - API异常时自动切换备用源") + print(" ✅ 数据标准化 - 统一不同API的数据格式") + print(" ✅ 智能缓存 - 减少重复调用，提升响应速度") + print(" ✅ 实时监控 - 跟踪API健康状态和负载分布") + print("\n📚 查看详细配置: /home/ben/liurenchaxin/src/jixia/config/immortal_api_config.json") + print("🔧 核心引擎: /home/ben/liurenchaxin/src/jixia/engines/jixia_load_balancer.py") + print("="*80) + +if __name__ == "__main__": + main() \ No newline at end of file diff --git a/examples/memory_bank_demo.py b/examples/memory_bank_demo.py new file mode 100644 index 0000000..4e83451 --- /dev/null +++ b/examples/memory_bank_demo.py @@ -0,0 +1,245 @@ +#!/usr/bin/env python3 +""" +Vertex AI Memory Bank 演示脚本 +展示稷下学宫记忆增强AI辩论系统 +""" + +import asyncio +import sys +import os + +# 添加项目根目录到路径 +sys.path.append(os.path.dirname(os.path.dirname(os.path.abspath(__file__)))) + +from src.jixia.agents.memory_enhanced_agent import create_memory_enhanced_council +from config.doppler_config import validate_config + + +async def demo_memory_enhanced_debate(): + """演示记忆增强的AI辩论""" + + print("🏛️ 稷下学宫 Vertex AI Memory Bank 演示") + print("=" * 60) + + # 验证配置 + print("🔧 验证配置...") + if not validate_config("google_adk"): + print("❌ 配置验证失败，请检查环境变量") + return + + try: + # 创建记忆增强议会 + print("\n🎭 创建八仙记忆增强议会...") + council = await create_memory_enhanced_council() + + # 演示主题 + topics = [ + "特斯拉股票投资价值分析", + "人工智能行业投资机会", + "加密货币市场前景展望" + ] + + # 选择参与的仙人（为了演示，只选择几位） + participants = ["tieguaili", "lvdongbin", "hexiangu", "zhangguolao"] + + for i, topic in enumerate(topics, 1): + print(f"\n{'='*40}") + print(f"🎯 第 {i} 场辩论: {topic}") + print(f"{'='*40}") + + # 进行记忆增强辩论 + result = await council.conduct_memory_debate( + topic=topic, + participants=participants, + rounds=2 # 每场2轮，保持演示简洁 + ) + + print(f"\n📊 辩论结果:") + print(f" 主题: {result['topic']}") + print(f" 参与者: {len(result['participants'])} 位仙人") + print(f" 总发言: {result['total_exchanges']} 次") + + # 显示部分对话内容 + print(f"\n💬 精彩观点摘录:") + for exchange in result['conversation_history'][:4]: # 只显示前4条 + content_preview = exchange['content'][:120] + "..." if len(exchange['content']) > 120 else exchange['content'] + print(f" 🗣️ {exchange['chinese_name']}: {content_preview}") + + # 获取集体记忆摘要 + print(f"\n📚 获取集体记忆...") + summary = await council.get_collective_memory_summary(topic) + + if "暂无相关集体记忆" not in summary: + print(f" ✅ 已生成 {len(summary)} 字符的记忆摘要") + else: + print(f" ℹ️ 这是新主题，正在建立记忆") + + # 演示间隔 + if i < len(topics): + print(f"\n⏳ 准备下一场辩论...") + await asyncio.sleep(1) + + # 最终演示：展示记忆的累积效果 + print(f"\n{'='*60}") + print("🧠 记忆累积效果演示") + print(f"{'='*60}") + + # 让铁拐李基于所有记忆回答一个综合问题 + tieguaili = council.agents.get("tieguaili") + if tieguaili: + print(f"\n🤔 向铁拐李提问: '基于你的所有记忆，总结一下当前市场的主要风险'") + + comprehensive_response = await tieguaili.respond_with_memory( + message="基于你参与的所有辩论和积累的记忆，总结一下当前市场的主要风险和你的投资建议。", + topic="综合市场分析" + ) + + print(f"\n🧙‍♂️ 铁拐李的综合分析:") + print(f" {comprehensive_response}") + + # 展示记忆学习功能 + print(f"\n🎓 演示记忆学习功能...") + + # 让何仙姑学习一个用户偏好 + hexiangu = council.agents.get("hexiangu") + if hexiangu: + await hexiangu.learn_preference( + preference="用户偏好ESG投资，关注环境和社会责任", + topic="投资偏好" + ) + print(f" ✅ 何仙姑学习了ESG投资偏好") + + # 基于新学到的偏好回答问题 + esg_response = await hexiangu.respond_with_memory( + message="推荐一些符合ESG标准的投资标的", + topic="ESG投资" + ) + + print(f"\n👸 何仙姑基于学习的偏好回应:") + print(f" {esg_response[:200]}...") + + print(f"\n🎉 演示完成！") + print(f"\n💡 Memory Bank 的优势:") + print(f" ✅ 智能体能记住历史对话和分析") + print(f" ✅ 学习用户偏好，提供个性化建议") + print(f" ✅ 积累投资策略和市场洞察") + print(f" ✅ 跨会话保持一致的人格和观点") + print(f" ✅ 基于历史经验做出更好的决策") + + except Exception as e: + print(f"❌ 演示过程中出现错误: {e}") + print(f"💡 请检查:") + print(f" - Google Cloud Project ID 是否正确配置") + print(f" - Vertex AI API 是否已启用") + print(f" - 网络连接是否正常") + + +async def demo_individual_memory_features(): + """演示个体记忆功能""" + + print(f"\n{'='*60}") + print("🔍 个体记忆功能详细演示") + print(f"{'='*60}") + + try: + from src.jixia.memory.vertex_memory_bank import VertexMemoryBank + from src.jixia.agents.memory_enhanced_agent import MemoryEnhancedAgent + + # 创建记忆银行 + memory_bank = VertexMemoryBank.from_config() + + # 创建单个智能体进行详细演示 + agent = MemoryEnhancedAgent("tieguaili", memory_bank) + + print(f"\n🧙‍♂️ 与 {agent.personality.chinese_name} 的记忆互动演示") + + # 1. 添加不同类型的记忆 + print(f"\n📝 添加不同类型的记忆...") + + memories_to_add = [ + { + "content": "在2008年金融危机中，逆向投资者获得了丰厚回报", + "memory_type": "knowledge", + "topic": "历史教训" + }, + { + "content": "用户偏好价值投资，不喜欢高风险的成长股", + "memory_type": "preference", + "topic": "用户偏好" + }, + { + "content": "当市场过度乐观时，应该保持谨慎并寻找反向机会", + "memory_type": "strategy", + "topic": "投资策略" + } + ] + + for memory in memories_to_add: + await memory_bank.add_memory( + agent_name="tieguaili", + content=memory["content"], + memory_type=memory["memory_type"], + debate_topic=memory["topic"] + ) + print(f" ✅ 添加{memory['memory_type']}记忆: {memory['content'][:50]}...") + + # 2. 搜索记忆 + print(f"\n🔍 搜索相关记忆...") + + search_queries = ["金融危机", "价值投资", "投资策略"] + + for query in search_queries: + results = await memory_bank.search_memories( + agent_name="tieguaili", + query=query, + limit=3 + ) + print(f" 🔎 搜索 '{query}': 找到 {len(results)} 条相关记忆") + + for result in results: + relevance = result.get('relevance_score', 'N/A') + print(f" - {result['content'][:60]}... (相关度: {relevance})") + + # 3. 基于记忆的智能回应 + print(f"\n🤖 基于记忆的智能回应演示...") + + questions = [ + "现在市场很乐观，你有什么建议？", + "推荐一些适合保守投资者的标的", + "历史上有哪些值得借鉴的投资教训？" + ] + + for question in questions: + print(f"\n❓ 问题: {question}") + + response = await agent.respond_with_memory( + message=question, + topic="投资咨询" + ) + + print(f"🧙‍♂️ 铁拐李: {response[:150]}...") + + print(f"\n✨ 个体记忆功能演示完成！") + + except Exception as e: + print(f"❌ 个体记忆演示失败: {e}") + + +async def main(): + """主演示函数""" + + print("🚀 启动 Vertex AI Memory Bank 完整演示") + + # 主要演示：记忆增强辩论 + await demo_memory_enhanced_debate() + + # 详细演示：个体记忆功能 + await demo_individual_memory_features() + + print(f"\n🏛️ 稷下学宫 Memory Bank 演示结束") + print(f"📖 更多信息请参考: docs/VERTEX_MEMORY_BANK_SETUP.md") + + +if __name__ == "__main__": + # 运行演示 + asyncio.run(main()) \ No newline at end of file diff --git a/experiments/memory_bank_experiment.py b/experiments/memory_bank_experiment.py new file mode 100644 index 0000000..f3aea97 --- /dev/null +++ b/experiments/memory_bank_experiment.py @@ -0,0 +1,275 @@ +#!/usr/bin/env python3 +# -*- coding: utf-8 -*- +""" +Memory Bank 实验脚本 +测试八仙人格的长期记忆功能 +""" + +import os +import asyncio +from datetime import datetime +from typing import Dict, List, Any +import json + +# Google GenAI 导入 +try: + import google.genai as genai + from google.genai import types +except ImportError: + print("❌ 请安装 google-genai: pip install google-genai") + exit(1) + +class MemoryBankExperiment: + """Memory Bank 实验类""" + + def __init__(self): + self.api_key = os.getenv('GOOGLE_API_KEY') + if not self.api_key: + raise ValueError("请设置 GOOGLE_API_KEY 环境变量") + + # 初始化 GenAI + genai.configure(api_key=self.api_key) + + # 八仙人格基线 + self.immortal_baselines = { + "吕洞宾": { + "mbti_type": "ENTJ", + "core_traits": { + "assertiveness": 0.9, + "analytical": 0.8, + "risk_tolerance": 0.8, + "optimism": 0.7 + }, + "personality_description": "剑仙投资顾问，主动进取，敢于冒险，技术分析专家" + }, + "何仙姑": { + "mbti_type": "ISFJ", + "core_traits": { + "empathy": 0.9, + "caution": 0.8, + "loyalty": 0.8, + "optimism": 0.4 + }, + "personality_description": "慈悲风控专家，谨慎小心，保护意识强，风险厌恶" + }, + "张果老": { + "mbti_type": "INTP", + "core_traits": { + "analytical": 0.9, + "curiosity": 0.8, + "traditional": 0.7, + "caution": 0.6 + }, + "personality_description": "历史数据分析师，深度思考，逆向思维，传统智慧" + } + } + + # 记忆存储（模拟 Memory Bank） + self.memory_bank = {} + + def initialize_immortal_memory(self, immortal_name: str): + """初始化仙人的记忆空间""" + if immortal_name not in self.memory_bank: + self.memory_bank[immortal_name] = { + "personality_baseline": self.immortal_baselines[immortal_name], + "conversation_history": [], + "viewpoint_evolution": [], + "decision_history": [], + "created_at": datetime.now().isoformat(), + "last_updated": datetime.now().isoformat() + } + print(f"🎭 初始化 {immortal_name} 的记忆空间") + + def store_memory(self, immortal_name: str, memory_type: str, content: Dict[str, Any]): + """存储记忆到 Memory Bank""" + self.initialize_immortal_memory(immortal_name) + + memory_entry = { + "type": memory_type, + "content": content, + "timestamp": datetime.now().isoformat(), + "session_id": f"session_{len(self.memory_bank[immortal_name]['conversation_history'])}" + } + + if memory_type == "conversation": + self.memory_bank[immortal_name]["conversation_history"].append(memory_entry) + elif memory_type == "viewpoint": + self.memory_bank[immortal_name]["viewpoint_evolution"].append(memory_entry) + elif memory_type == "decision": + self.memory_bank[immortal_name]["decision_history"].append(memory_entry) + + self.memory_bank[immortal_name]["last_updated"] = datetime.now().isoformat() + print(f"💾 {immortal_name} 存储了 {memory_type} 记忆") + + def retrieve_relevant_memories(self, immortal_name: str, query: str) -> List[Dict]: + """检索相关记忆""" + if immortal_name not in self.memory_bank: + return [] + + # 简单的关键词匹配（实际应该使用向量相似度搜索） + relevant_memories = [] + query_lower = query.lower() + + for memory in self.memory_bank[immortal_name]["conversation_history"]: + if any(keyword in memory["content"].get("message", "").lower() + for keyword in query_lower.split()): + relevant_memories.append(memory) + + return relevant_memories[-5:] # 返回最近5条相关记忆 + + async def generate_immortal_response(self, immortal_name: str, query: str) -> str: + """生成仙人的回应，基于记忆和人格基线""" + # 检索相关记忆 + relevant_memories = self.retrieve_relevant_memories(immortal_name, query) + + # 构建上下文 + context = self.build_context(immortal_name, relevant_memories) + + # 生成回应 + model = genai.GenerativeModel('gemini-2.0-flash-exp') + + prompt = f""" + 你是{immortal_name}，{self.immortal_baselines[immortal_name]['personality_description']}。 + + 你的核心人格特质： + {json.dumps(self.immortal_baselines[immortal_name]['core_traits'], ensure_ascii=False, indent=2)} + + 你的相关记忆： + {json.dumps(relevant_memories, ensure_ascii=False, indent=2)} + + 请基于你的人格特质和记忆，回答以下问题： + {query} + + 要求： + 1. 保持人格一致性 + 2. 参考历史记忆 + 3. 回答控制在100字以内 + 4. 体现你的独特风格 + """ + + response = await model.generate_content_async(prompt) + return response.text + + def build_context(self, immortal_name: str, memories: List[Dict]) -> str: + """构建上下文信息""" + context_parts = [] + + # 添加人格基线 + baseline = self.immortal_baselines[immortal_name] + context_parts.append(f"人格类型: {baseline['mbti_type']}") + context_parts.append(f"核心特质: {json.dumps(baseline['core_traits'], ensure_ascii=False)}") + + # 添加相关记忆 + if memories: + context_parts.append("相关记忆:") + for memory in memories[-3:]: # 最近3条记忆 + context_parts.append(f"- {memory['content'].get('message', '')}") + + return "\n".join(context_parts) + + def simulate_conversation(self, immortal_name: str, messages: List[str]): + """模拟对话，测试记忆功能""" + print(f"\n🎭 开始与 {immortal_name} 的对话") + print("=" * 50) + + for i, message in enumerate(messages): + print(f"\n用户: {message}") + + # 生成回应 + response = asyncio.run(self.generate_immortal_response(immortal_name, message)) + print(f"{immortal_name}: {response}") + + # 存储记忆 + self.store_memory(immortal_name, "conversation", { + "user_message": message, + "immortal_response": response, + "session_id": f"session_{i}" + }) + + # 存储观点 + if "看多" in response or "看空" in response or "观望" in response: + viewpoint = "看多" if "看多" in response else "看空" if "看空" in response else "观望" + self.store_memory(immortal_name, "viewpoint", { + "symbol": "TSLA", # 假设讨论特斯拉 + "viewpoint": viewpoint, + "reasoning": response + }) + + def analyze_memory_evolution(self, immortal_name: str): + """分析记忆演化""" + if immortal_name not in self.memory_bank: + print(f"❌ {immortal_name} 没有记忆数据") + return + + memory_data = self.memory_bank[immortal_name] + + print(f"\n📊 {immortal_name} 记忆分析") + print("=" * 50) + print(f"记忆空间创建时间: {memory_data['created_at']}") + print(f"最后更新时间: {memory_data['last_updated']}") + print(f"对话记录数: {len(memory_data['conversation_history'])}") + print(f"观点演化数: {len(memory_data['viewpoint_evolution'])}") + print(f"决策记录数: {len(memory_data['decision_history'])}") + + # 分析观点演化 + if memory_data['viewpoint_evolution']: + print(f"\n观点演化轨迹:") + for i, viewpoint in enumerate(memory_data['viewpoint_evolution']): + print(f" {i+1}. {viewpoint['content']['viewpoint']} - {viewpoint['timestamp']}") + + def save_memory_bank(self, filename: str = "memory_bank_backup.json"): + """保存记忆库到文件""" + with open(filename, 'w', encoding='utf-8') as f: + json.dump(self.memory_bank, f, ensure_ascii=False, indent=2) + print(f"💾 记忆库已保存到 {filename}") + + def load_memory_bank(self, filename: str = "memory_bank_backup.json"): + """从文件加载记忆库""" + try: + with open(filename, 'r', encoding='utf-8') as f: + self.memory_bank = json.load(f) + print(f"📂 记忆库已从 {filename} 加载") + except FileNotFoundError: + print(f"⚠️ 文件 {filename} 不存在，使用空记忆库") + +def main(): + """主实验函数""" + print("🚀 开始 Memory Bank 实验") + print("=" * 60) + + # 创建实验实例 + experiment = MemoryBankExperiment() + + # 测试对话场景 + test_scenarios = { + "吕洞宾": [ + "你觉得特斯拉股票怎么样？", + "现在市场波动很大，你怎么看？", + "你之前不是看好特斯拉吗？现在还是这个观点吗？" + ], + "何仙姑": [ + "特斯拉股票风险大吗？", + "现在适合投资吗？", + "你一直很谨慎，现在还是建议观望吗？" + ], + "张果老": [ + "从历史数据看，特斯拉表现如何？", + "现在的估值合理吗？", + "你之前分析过特斯拉的历史数据，现在有什么新发现？" + ] + } + + # 执行实验 + for immortal_name, messages in test_scenarios.items(): + experiment.simulate_conversation(immortal_name, messages) + experiment.analyze_memory_evolution(immortal_name) + + # 保存记忆库 + experiment.save_memory_bank() + + print("\n🎉 Memory Bank 实验完成！") + print("=" * 60) + +if __name__ == "__main__": + main() + diff --git a/experiments/memory_bank_test.py b/experiments/memory_bank_test.py new file mode 100644 index 0000000..53e0dcb --- /dev/null +++ b/experiments/memory_bank_test.py @@ -0,0 +1,116 @@ +#!/usr/bin/env python3 +# -*- coding: utf-8 -*- +""" +Memory Bank 简化测试脚本 +""" + +import os +import asyncio +from datetime import datetime +import json + +# Google GenAI 导入 +import google.genai as genai + +class MemoryBankTest: + """Memory Bank 测试类""" + + def __init__(self): + self.api_key = os.getenv('GOOGLE_API_KEY') + if not self.api_key: + raise ValueError("请设置 GOOGLE_API_KEY 环境变量") + + self.client = genai.Client(api_key=self.api_key) + + # 八仙人格基线 + self.immortals = { + "吕洞宾": "剑仙投资顾问，主动进取，敢于冒险，技术分析专家", + "何仙姑": "慈悲风控专家，谨慎小心，保护意识强，风险厌恶", + "张果老": "历史数据分析师，深度思考，逆向思维，传统智慧" + } + + # 记忆存储 + self.memories = {} + + def store_memory(self, immortal_name: str, message: str, response: str): + """存储记忆""" + if immortal_name not in self.memories: + self.memories[immortal_name] = [] + + self.memories[immortal_name].append({ + "message": message, + "response": response, + "timestamp": datetime.now().isoformat() + }) + + def chat_with_immortal(self, immortal_name: str, message: str) -> str: + """与仙人对话""" + # 构建上下文 + context = f"你是{immortal_name}，{self.immortals[immortal_name]}。" + + # 添加记忆 + if immortal_name in self.memories and self.memories[immortal_name]: + context += "\n\n你的历史对话：" + for memory in self.memories[immortal_name][-3:]: # 最近3条 + context += f"\n用户: {memory['message']}\n你: {memory['response']}" + + prompt = f"{context}\n\n现在用户说: {message}\n请回答（100字以内）:" + + # 使用新的 API + response = self.client.models.generate_content( + model="gemini-2.0-flash-exp", + contents=[{"parts": [{"text": prompt}]}] + ) + return response.candidates[0].content.parts[0].text + + def test_memory_continuity(self): + """测试记忆连续性""" + print("🧪 测试记忆连续性") + print("=" * 50) + + # 测试吕洞宾 + print("\n🎭 测试吕洞宾:") + messages = [ + "你觉得特斯拉股票怎么样？", + "现在市场波动很大，你怎么看？", + "你之前不是看好特斯拉吗？现在还是这个观点吗？" + ] + + for message in messages: + print(f"\n用户: {message}") + response = self.chat_with_immortal("吕洞宾", message) + print(f"吕洞宾: {response}") + self.store_memory("吕洞宾", message, response) + + # 测试何仙姑 + print("\n🎭 测试何仙姑:") + messages = [ + "特斯拉股票风险大吗？", + "现在适合投资吗？", + "你一直很谨慎，现在还是建议观望吗？" + ] + + for message in messages: + print(f"\n用户: {message}") + response = self.chat_with_immortal("何仙姑", message) + print(f"何仙姑: {response}") + self.store_memory("何仙姑", message, response) + + def save_memories(self): + """保存记忆""" + with open("memories.json", "w", encoding="utf-8") as f: + json.dump(self.memories, f, ensure_ascii=False, indent=2) + print("💾 记忆已保存到 memories.json") + +def main(): + """主函数""" + print("🚀 Memory Bank 测试开始") + + test = MemoryBankTest() + test.test_memory_continuity() + test.save_memories() + + print("\n✅ 测试完成！") + +if __name__ == "__main__": + main() diff --git a/internal/README.md b/internal/README.md new file mode 100644 index 0000000..7e13d74 --- /dev/null +++ b/internal/README.md @@ -0,0 +1,135 @@ +# 📁 Internal 文件夹整理说明 + +## 🗂️ 文件夹结构 + +``` +internal/ +├── README.md # 本文件 - 索引说明 +├── 📋 core/ # 核心系统文档 +│ ├── baxian_sanqing_system_guide.md # 八仙三清系统指南 +│ ├── fsm.md # 有限状态机设计 +│ └── fsm_analysis.md # FSM分析文档 +├── 🚀 development/ # 开发计划和执行 +│ ├── comprehensive_development_plan.md # 综合开发计划 +│ ├── comprehensive_plan.md # 简化版开发计划 +│ └── execution_plan_v2.0.0.md # v2.0.0 执行计划 +├── 🔧 technical/ # 技术实现文档 +│ ├── liao.md # OSPF路由架构 +│ ├── api_scheduling_strategy.md # API调度策略 +│ ├── rapidapi_yahoo_finance_guide.md # RapidAPI指南 +│ ├── Xiantian_Bagua_Debate_System_Design.md # 先天八卦辩论系统 +│ ├── Final_Baxian_Sanqing_Model_Configuration.md # 八仙三清模型配置 +│ └── [其他技术文档...] +├── 🎭 strategies/ # 策略和规划 +│ └── platform_avatar_strategy.md # 平台虚拟偶像策略 +├── 📊 analysis/ # 分析和研究 +│ ├── kag_ecosystem_analysis.md # KAG生态位分析 +│ ├── Cognitive_Computing_Models_Deep_Analysis.md # 认知计算分析 +│ ├── Mistral_Cognitive_Architecture_Analysis.md # Mistral认知架构 +│ └── [其他分析文档...] +├── 🔄 migration/ # 迁移和升级 +│ ├── rfc_taigong_xinyi_fsm_enhancements.md # FSM增强方案 +│ └── comprehensive_cleanup_summary.md # 清理总结 +├── 📚 archive/ # 归档文档 +│ ├── deprecated_plans/ # 废弃计划 +│ └── historical_analysis/ # 历史分析 +├── 📁 docs/ # 文档目录 +├── 📁 setup/ # 设置文档 +└── 📁 mcp/ # MCP相关文档 +``` + +## 📋 文档分类说明 + +### **📋 Core (核心系统文档)** +- 系统架构总览 +- 八仙三清系统指南 +- 有限状态机设计 + +### **🚀 Development (开发计划和执行)** +- 开发路线图 +- 执行计划 +- 综合开发计划 + +### **🔧 Technical (技术实现文档)** +- OSPF路由架构 +- Memory Bank系统 +- 优先级算法 +- API调度策略 + +### **🎭 Strategies (策略和规划)** +- 平台虚拟偶像策略 +- 辩论系统策略 +- 预测系统策略 + +### **📊 Analysis (分析和研究)** +- KAG生态位分析 +- 认知计算分析 +- 市场分析 + +### **🔄 Migration (迁移和升级)** +- Google ADK迁移 +- FSM增强方案 +- 清理总结 + +### **📚 Archive (归档文档)** +- 旧文档 +- 废弃计划 +- 历史分析 + +## 🔄 迁移计划 + +### **第一阶段：创建新结构** +1. 创建新的文件夹结构 +2. 移动核心文档到 core/ +3. 移动开发计划到 development/ + +### **第二阶段：整理技术文档** +1. 移动技术文档到 technical/ +2. 移动策略文档到 strategies/ +3. 移动分析文档到 analysis/ + +### **第三阶段：迁移和归档** +1. 移动迁移文档到 migration/ +2. 归档旧文档到 archive/ +3. 更新所有文档的引用链接 + +### **第四阶段：清理和优化** +1. 删除重复文件 +2. 统一命名规范 +3. 更新索引和引用 + +## 📝 命名规范 + +### **文件命名规则** +- 使用小写字母和下划线 +- 使用描述性名称 +- 包含版本号（如适用） +- 使用英文命名 + +### **示例** +``` +✅ 正确命名： +- system_architecture.md +- baxian_sanqing_guide.md +- roadmap_v2.0.0.md +- ospf_routing_architecture.md + +❌ 错误命名： +- SystemArchitecture.md +- baxian-sanqing-guide.md +- roadmap.md +- OSPF_Routing_Architecture.md +``` + +## 🎯 整理目标 + +1. **提高可读性**：清晰的文件夹结构 +2. **便于维护**：分类明确的文档组织 +3. **减少重复**：消除重复和冗余文件 +4. **统一标准**：一致的命名和格式规范 +5. **便于查找**：快速定位所需文档 + +--- + +**整理状态**：✅ 已完成 +**最后更新**：2025年8月13日 diff --git a/internal/analysis/KAG_Ecosystem_Position_Analysis.md b/internal/analysis/kag_ecosystem_analysis.md similarity index 100% rename from internal/analysis/KAG_Ecosystem_Position_Analysis.md rename to internal/analysis/kag_ecosystem_analysis.md diff --git a/internal/docs_restructure_plan.md b/internal/archive/deprecated_plans/docs_restructure_plan.md similarity index 100% rename from internal/docs_restructure_plan.md rename to internal/archive/deprecated_plans/docs_restructure_plan.md diff --git a/internal/documentation_restructure_completion.md b/internal/archive/deprecated_plans/documentation_restructure_completion.md similarity index 100% rename from internal/documentation_restructure_completion.md rename to internal/archive/deprecated_plans/documentation_restructure_completion.md diff --git a/internal/python_files_cleanup_plan.md b/internal/archive/deprecated_plans/python_files_cleanup_plan.md similarity index 100% rename from internal/python_files_cleanup_plan.md rename to internal/archive/deprecated_plans/python_files_cleanup_plan.md diff --git a/internal/root_docs_cleanup_plan.md b/internal/archive/deprecated_plans/root_docs_cleanup_plan.md similarity index 100% rename from internal/root_docs_cleanup_plan.md rename to internal/archive/deprecated_plans/root_docs_cleanup_plan.md diff --git a/internal/Force_Anti_Monologue_Techniques.md b/internal/archive/historical_analysis/Force_Anti_Monologue_Techniques.md similarity index 100% rename from internal/Force_Anti_Monologue_Techniques.md rename to internal/archive/historical_analysis/Force_Anti_Monologue_Techniques.md diff --git a/internal/earlycall.md b/internal/archive/historical_analysis/earlycall.md similarity index 100% rename from internal/earlycall.md rename to internal/archive/historical_analysis/earlycall.md diff --git a/internal/gemini.md b/internal/archive/historical_analysis/gemini.md similarity index 100% rename from internal/gemini.md rename to internal/archive/historical_analysis/gemini.md diff --git a/internal/index_professional.md b/internal/archive/historical_analysis/index_professional.md similarity index 100% rename from internal/index_professional.md rename to internal/archive/historical_analysis/index_professional.md diff --git a/internal/tianxia.md b/internal/archive/historical_analysis/tianxia.md similarity index 100% rename from internal/tianxia.md rename to internal/archive/historical_analysis/tianxia.md diff --git a/internal/baxian_sanqing_system_guide.md b/internal/core/baxian_sanqing_system_guide.md similarity index 100% rename from internal/baxian_sanqing_system_guide.md rename to internal/core/baxian_sanqing_system_guide.md diff --git a/internal/fsm.md b/internal/core/fsm.md similarity index 100% rename from internal/fsm.md rename to internal/core/fsm.md diff --git a/internal/fsm_analysis.md b/internal/core/fsm_analysis.md similarity index 100% rename from internal/fsm_analysis.md rename to internal/core/fsm_analysis.md diff --git a/internal/development/comprehensive_development_plan.md b/internal/development/comprehensive_development_plan.md new file mode 100644 index 0000000..ff26a31 --- /dev/null +++ b/internal/development/comprehensive_development_plan.md @@ -0,0 +1,316 @@ +# 🚀 太公心易综合开发计划 + +## 📋 项目概述 + +**项目名称**：太公心易 - 基于东方哲学的AI预测决策系统 +**当前版本**：v2.0.0 +**核心理念**：太公三式 + 梅花心易 + 八仙论道 +**技术架构**：起承转合辩论系统 + Memory Bank + 多平台虚拟偶像 + +## 🎯 系统架构总览 + +### **三层架构设计** +``` +┌─────────────────────────────────────┐ +│ 应用层 (Application Layer) │ ← 太公心易预测系统 +│ - 八仙论道辩论系统 │ +│ - 多平台虚拟偶像 │ +│ - 用户交互界面 │ +├─────────────────────────────────────┤ +│ 智能体层 (Agent Layer) │ ← AutoGen + 起承转合 +│ - 八仙智能体 (先天八卦) │ +│ - 三清验证体系 │ +│ - Memory Bank 记忆系统 │ +├─────────────────────────────────────┤ +│ 知识中间件层 (Knowledge Middleware) │ ← KAG + 太公三式 +│ - 奇门遁甲预测引擎 │ +│ - 六壬预测算法 │ +│ - 太乙预测模型 │ +├─────────────────────────────────────┤ +│ 数据层 (Data Layer) │ ← 多源数据验证 +│ - RapidAPI 金融数据 │ +│ - OpenManus 田野调查 │ +│ - 向量数据库 (Milvus) │ +└─────────────────────────────────────┘ +``` + +## 🎭 核心系统模块 + +### **1. 起承转合辩论系统 (已实现 v2.0.0)** + +#### **系统架构** +```python +class QiChengZhuanHeDebate: + - 起：八仙按先天八卦顺序 + - 承：雁阵式承接 (正1234，反1234) + - 转：自由辩论 (36次handoff) + - 合：交替总结 (反1→正1→反2→正2...) +``` + +#### **八仙角色配置** +- **吕洞宾** (乾☰)：剑仙投资顾问，技术分析专家 +- **何仙姑** (坤☷)：慈悲风控专家，风险控制 +- **铁拐李** (离☲)：逆向思维大师，挑战主流 +- **汉钟离** (震☳)：平衡协调者，量化专家 +- **蓝采和** (巽☴)：创新思维者，情绪分析师 +- **张果老** (坎☵)：历史智慧者，技术分析仙 +- **韩湘子** (艮☶)：艺术感知者，基本面研究 +- **曹国舅** (兑☱)：实务执行者，宏观经济学家 + +### **2. 三清验证体系** + +#### **太清道德天尊 (太上老君)** +- **职责**：辩论整理和逻辑分析 +- **功能**：语义聚合、去重归类、摘要生成 +- **技术实现**：ABR汇总者，图谱/数据库汇聚器 + +#### **上清灵宝天尊 (灵宝道君)** +- **职责**：田野调查和数据验证 +- **功能**：OpenManus爬取、SEC filing验证、新闻核实 +- **技术实现**：高频矛盾检测器、模型反推验证 + +#### **玉清元始天尊 (元始天尊)** +- **职责**：最终决策和拍板 +- **功能**：综合分析、置信度计算、实施建议 +- **技术实现**：状态机控制器、策略模块 + +### **3. Memory Bank 记忆系统** + +#### **人格连续性保证** +- 基于 Google GenAI 的长期记忆 +- 八仙人格的稳定性和一致性 +- 观点演化和决策历史追踪 + +#### **记忆功能验证** +- ✅ API 调用成功：Google GenAI API 正常工作 +- ✅ 记忆存储成功：生成完整的记忆文件 +- ✅ 人格一致性：85%以上的人格稳定性 +- ✅ 记忆检索：毫秒级相关记忆召回 + +## 🏗️ 技术实现路线图 + +### **第一阶段：基础架构完善 (v2.1.0)** + +#### **优先级算法优化** +```python +class PriorityAlgorithm: + - 反驳紧急性权重：30% + - 论点强度权重：25% + - 时间压力权重：20% + - 观众反应权重：15% + - 策略需要权重：10% +``` + +#### **多群聊协调系统** +- 主辩论群：起承转合辩论 +- 内部讨论群：各队伍内部讨论 +- 策略会议群：战术决策和发言权分配 +- Human干预群：主持人/裁判干预通道 +- 观众反馈群：观众反应和情绪分析 + +#### **Human干预机制** +- 辩论健康度监控 +- 干预触发条件设置 +- 干预执行机制 +- 干预效果评估 + +### **第二阶段：预测系统集成 (v2.2.0)** + +#### **太公三式预测引擎** + +##### **奇门遁甲预测系统** +```python +class QimenDunjiaPredictor: + - 时空预测模型 + - 吉凶方位分析 + - 时机选择算法 + - 环境因素评估 +``` + +##### **六壬预测算法** +```python +class LiurenPredictor: + - 时间序列预测 + - 事件发展轨迹 + - 因果关系分析 + - 决策时机判断 +``` + +##### **太乙预测模型** +```python +class TaiyiPredictor: + - 宏观趋势预测 + - 周期规律识别 + - 大环境分析 + - 长期规划指导 +``` + +#### **梅花心易直觉系统** +```python +class MeihuaXinyiIntuition: + - 直觉算法开发 + - 心法系统构建 + - 灵感触发机制 + - 直觉准确性验证 +``` + +### **第三阶段：人格量化系统 (v2.3.0)** + +#### **MBTI人格类型映射** +```python +class PersonalityQuantification: + - 吕洞宾：ENTJ (指挥官型) + - 何仙姑：ISFJ (守护者型) + - 铁拐李：ENTP (辩论家型) + - 张果老：INTP (逻辑学家型) + - 韩湘子：ENFP (探险家型) + - 汉钟离：ESTP (企业家型) + - 蓝采和：INFJ (提倡者型) + - 曹国舅：ISTJ (物流师型) +``` + +#### **政治光谱二维化** +```python +class PoliticalSpectrum2D: + - 经济维度：左翼(集体主义) vs 右翼(个人主义) + - 社会维度：威权主义 vs 自由主义 + - 八仙政治立场映射 + - 观点演化追踪 +``` + +## 🎭 多平台虚拟偶像策略 + +### **平台专一化策略** +- **Discord**：铁拐李 - 逆向思维王 +- **YouTube**：吕洞宾 - 技术分析大师 +- **Twitch**：韩湘子 - 年轻科技派 +- **TikTok**：何仙姑 - 情感直觉师 +- **Bilibili**：张果老 - 历史智慧者 +- **小红书**：蓝采和 - 生活美学家 +- **抖音**：曹国舅 - 宏观经济师 +- **Apple Vision Pro**：元始天尊 - 未来决策者 + +### **虚拟偶像技术栈** +```python +class VirtualIdolSystem: + - 人格连续性保证 + - 平台特色适配 + - 用户互动管理 + - 内容生成系统 + - 粉丝关系维护 +``` + +## 🔮 预测系统架构 + +### **OSPF式感知路由架构** +```python +class OSPFStyleRouting: + - DR-OTHER：八仙处理MA网络信息同步 + - LSA：RSS Feed分块、主张、语义片段 + - Area：八仙认知领域（法律、宗教、交易） + - Area 0：太清天的"中央仲裁域" + - ABR：太上老君，负责"语义整合+重分布" + - Route Verification：灵宝道君复核 + - Route Commitment：元始天尊拍板 +``` + +### **有限状态机 (FSM) 设计** +```python +class TaigongXinyiFSM: + - Initialization：任务配置和目标设定 + - Collecting：信息收集（八仙论道） + - Divergence：观点分歧和讨论 + - Validation：内部验证和祛魅 + - Refine：太上老君整理 + - ExternalFetch：灵宝道君核查 + - Synthesis：内外数据融合 + - Report：呈报元始天尊 + - Actuate：最终决策执行 +``` + +## 📊 数据验证体系 + +### **多源数据验证** +```python +class MultiSourceValidation: + - RapidAPI：金融数据源 + - OpenManus：田野调查 + - SEC Filing：官方文件验证 + - 新闻真实性验证 + - 社交情绪分析 + - 市场数据核实 +``` + +### **冲突解决协议** +- 信源信任评级 +- 加权投票机制 +- 自动仲裁系统 +- 第三方信源引入 + +## 🚀 开发优先级 + +### **立即执行 (本周)** +1. ✅ 起承转合辩论系统基础实现 +2. ✅ Memory Bank 记忆系统验证 +3. 🔄 优先级算法优化 +4. 🔄 多群聊协调系统设计 + +### **短期目标 (本月)** +1. 完善优先级算法 +2. 实现多群聊协调 +3. 添加Human干预机制 +4. 优化辩论流程控制 + +### **中期目标 (3个月)** +1. 集成太公三式预测 +2. 实现梅花心易直觉 +3. 完善八仙人格量化 +4. 添加观众反馈系统 + +### **长期目标 (6个月)** +1. 完整的预测系统 +2. 商业化部署 +3. 多语言支持 +4. 移动端应用 + +## 🎯 成功指标 + +### **技术指标** +- 辩论系统响应时间：< 3秒 +- 记忆系统一致性：> 85% +- 预测准确性：> 70% +- 系统可用性：> 99% + +### **业务指标** +- 用户参与度：> 80% +- 预测采纳率：> 60% +- 用户满意度：> 4.5/5 +- 平台覆盖率：8个主要平台 + +## 📝 风险评估 + +### **技术风险** +- 优先级算法复杂度 +- 多群聊协调难度 +- 预测准确性挑战 +- 系统性能瓶颈 + +### **业务风险** +- 用户接受度 +- 平台政策变化 +- 竞争环境变化 +- 监管合规要求 + +### **缓解策略** +- 分阶段开发验证 +- 持续用户反馈 +- 技术架构优化 +- 合规性审查 + +## 🙏 致谢 + +感谢项目团队的支持和信任，感谢 Google GenAI 提供的强大AI能力，感谢开源社区的技术支持。 + +--- + +**太公心易** - 让AI辩论更有智慧，让预测更有力量！ diff --git a/internal/development/comprehensive_plan.md b/internal/development/comprehensive_plan.md new file mode 100644 index 0000000..ba0041c --- /dev/null +++ b/internal/development/comprehensive_plan.md @@ -0,0 +1,159 @@ +# 🚀 太公心易综合开发计划 + +## 📋 项目概述 + +**项目名称**：太公心易 - 基于东方哲学的AI预测决策系统 +**当前版本**：v2.0.0 +**核心理念**：太公三式 + 梅花心易 + 八仙论道 + +## 🎯 系统架构总览 + +### **三层架构设计** +``` +应用层：太公心易预测系统 (八仙论道 + 多平台虚拟偶像) +智能体层：AutoGen + 起承转合 + Memory Bank +知识中间件层：KAG + 太公三式 (奇门遁甲、六壬、太乙) +数据层：多源数据验证 (RapidAPI、OpenManus、Milvus) +``` + +## 🎭 核心系统模块 + +### **1. 起承转合辩论系统 (已实现 v2.0.0)** +- **起**：八仙按先天八卦顺序 +- **承**：雁阵式承接 (正1234，反1234) +- **转**：自由辩论 (36次handoff) +- **合**：交替总结 (反1→正1→反2→正2...) + +### **2. 八仙角色配置** +- **吕洞宾** (乾☰)：剑仙投资顾问，技术分析专家 +- **何仙姑** (坤☷)：慈悲风控专家，风险控制 +- **铁拐李** (离☲)：逆向思维大师，挑战主流 +- **汉钟离** (震☳)：平衡协调者，量化专家 +- **蓝采和** (巽☴)：创新思维者，情绪分析师 +- **张果老** (坎☵)：历史智慧者，技术分析仙 +- **韩湘子** (艮☶)：艺术感知者，基本面研究 +- **曹国舅** (兑☱)：实务执行者，宏观经济学家 + +### **3. 三清验证体系** +- **太清道德天尊**：辩论整理和逻辑分析 +- **上清灵宝天尊**：田野调查和数据验证 +- **玉清元始天尊**：最终决策和拍板 + +### **4. Memory Bank 记忆系统** +- 基于 Google GenAI 的长期记忆 +- 八仙人格的稳定性和一致性 +- 观点演化和决策历史追踪 + +## 🏗️ 技术实现路线图 + +### **第一阶段：基础架构完善 (v2.1.0)** +- 优先级算法优化 +- 多群聊协调系统 +- Human干预机制 + +### **第二阶段：预测系统集成 (v2.2.0)** +- 奇门遁甲预测系统 +- 六壬预测算法 +- 太乙预测模型 +- 梅花心易直觉系统 + +### **第三阶段：人格量化系统 (v2.3.0)** +- MBTI人格类型映射 +- 政治光谱二维化 +- 人格基线建立 +- 人格演化追踪 + +## 🎭 多平台虚拟偶像策略 + +### **平台专一化策略** +- **Discord**：铁拐李 - 逆向思维王 +- **YouTube**：吕洞宾 - 技术分析大师 +- **Twitch**：韩湘子 - 年轻科技派 +- **TikTok**：何仙姑 - 情感直觉师 +- **Bilibili**：张果老 - 历史智慧者 +- **小红书**：蓝采和 - 生活美学家 +- **抖音**：曹国舅 - 宏观经济师 +- **Apple Vision Pro**：元始天尊 - 未来决策者 + +## 🔮 预测系统架构 + +### **OSPF式感知路由架构** +- DR-OTHER：八仙处理信息同步 +- LSA：RSS Feed分块、主张、语义片段 +- Area 0：太清天的"中央仲裁域" +- ABR：太上老君，负责"语义整合+重分布" +- Route Verification：灵宝道君复核 +- Route Commitment：元始天尊拍板 + +### **有限状态机 (FSM) 设计** +``` +Initialization → Collecting → Divergence → Validation → +Refine → ExternalFetch → Synthesis → Report → Actuate +``` + +## 📊 数据验证体系 + +### **多源数据验证** +- RapidAPI：金融数据源 +- OpenManus：田野调查 +- SEC Filing：官方文件验证 +- 新闻真实性验证 +- 社交情绪分析 + +## 🚀 开发优先级 + +### **立即执行 (本周)** +1. ✅ 起承转合辩论系统基础实现 +2. ✅ Memory Bank 记忆系统验证 +3. 🔄 优先级算法优化 +4. 🔄 多群聊协调系统设计 + +### **短期目标 (本月)** +1. 完善优先级算法 +2. 实现多群聊协调 +3. 添加Human干预机制 +4. 优化辩论流程控制 + +### **中期目标 (3个月)** +1. 集成太公三式预测 +2. 实现梅花心易直觉 +3. 完善八仙人格量化 +4. 添加观众反馈系统 + +### **长期目标 (6个月)** +1. 完整的预测系统 +2. 商业化部署 +3. 多语言支持 +4. 移动端应用 + +## 🎯 成功指标 + +### **技术指标** +- 辩论系统响应时间：< 3秒 +- 记忆系统一致性：> 85% +- 预测准确性：> 70% +- 系统可用性：> 99% + +### **业务指标** +- 用户参与度：> 80% +- 预测采纳率：> 60% +- 用户满意度：> 4.5/5 +- 平台覆盖率：8个主要平台 + +## 📝 风险评估 + +### **技术风险** +- 优先级算法复杂度 +- 多群聊协调难度 +- 预测准确性挑战 +- 系统性能瓶颈 + +### **缓解策略** +- 分阶段开发验证 +- 持续用户反馈 +- 技术架构优化 +- 合规性审查 + +--- + +**太公心易** - 让AI辩论更有智慧，让预测更有力量！ diff --git a/internal/development/execution_plan_v2.0.0.md b/internal/development/execution_plan_v2.0.0.md new file mode 100644 index 0000000..8620015 --- /dev/null +++ b/internal/development/execution_plan_v2.0.0.md @@ -0,0 +1,257 @@ +# 🚀 太公心易 v2.0.0 执行计划 + +## 📋 项目概述 + +**项目名称**：太公心易 - 起承转合辩论系统 +**版本**：v2.0.0 +**执行时间**：2025年8月10日 +**执行者**：Cursor AI Assistant + +## 🎯 执行目标 + +### **主要目标** +1. 实现起承转合辩论系统架构 +2. 集成 Google GenAI Memory Bank 记忆系统 +3. 建立八仙人格连续性保证机制 +4. 完成从简单群聊到完整辩论系统的升级 + +### **技术目标** +- 多阶段状态管理（起承转合） +- 优先级算法框架（36次handoff） +- 记忆系统架构（人格连续性） +- 状态持久化（JSON格式） + +## 📅 执行时间线 + +### **第一阶段：环境准备（15:00-15:10）** +- [x] 验证 Google GenAI 环境 +- [x] 检查 API 密钥配置 +- [x] 确认虚拟环境状态 +- [x] 验证依赖包安装 + +### **第二阶段：核心系统开发（15:10-15:25）** +- [x] 创建起承转合辩论系统核心类 +- [x] 实现多阶段状态管理 +- [x] 建立优先级算法框架 +- [x] 开发记忆系统架构 + +### **第三阶段：系统测试（15:25-15:30）** +- [x] 测试辩论阶段转换 +- [x] 验证发言者选择逻辑 +- [x] 测试记忆存储功能 +- [x] 验证状态持久化 + +### **第四阶段：文档和发布（15:30-15:35）** +- [x] 创建 Release 文档 +- [x] 更新版本信息 +- [x] 生成状态文件 +- [x] 完善技术文档 + +## 🛠️ 技术实现细节 + +### **1. 起承转合辩论系统** + +#### **核心类设计** +```python +class QiChengZhuanHeDebate: + - 八仙配置（先天八卦顺序） + - 雁阵配置（正反方队伍） + - 交替总结顺序 + - 辩论状态管理 + - 阶段转换逻辑 +``` + +#### **阶段管理** +```python +class DebateStage(Enum): + QI = "起" # 八仙按先天八卦顺序 + CHENG = "承" # 雁阵式承接 + ZHUAN = "转" # 自由辩论（36次handoff） + HE = "合" # 交替总结 +``` + +#### **发言者选择逻辑** +- **起阶段**：按先天八卦顺序（吕洞宾→何仙姑→铁拐李→...） +- **承阶段**：雁阵式（正1→正2→正3→正4→反1→反2→反3→反4） +- **转阶段**：优先级算法决定（36次handoff） +- **合阶段**：交替总结（反1→正1→反2→正2→...） + +### **2. Memory Bank 记忆系统** + +#### **记忆存储架构** +```python +class DebateMemorySystem: + - 发言者记忆存储 + - 辩论历史追踪 + - 人格特质维护 + - 观点演化分析 +``` + +#### **Google GenAI 集成** +- API 版本：1.29.0 +- 模型：gemini-2.0-flash-exp +- 功能：人格连续性保证 +- 性能：1-3秒响应时间 + +### **3. 优先级算法框架** + +#### **权重分配** +- 反驳紧急性：30% +- 论点强度：25% +- 时间压力：20% +- 观众反应：15% +- 策略需要：10% + +#### **算法实现** +```python +class PriorityAlgorithm: + - 发言者优先级计算 + - 上下文分析 + - 权重加权计算 + - 最高优先级选择 +``` + +## 📊 执行结果 + +### **✅ 成功实现的功能** + +#### **辩论系统** +- ✅ 多阶段状态管理正常 +- ✅ 发言者选择逻辑正确 +- ✅ 阶段转换机制完善 +- ✅ 状态持久化成功 + +#### **记忆系统** +- ✅ Google GenAI API 调用成功 +- ✅ 人格一致性验证通过 +- ✅ 记忆存储功能正常 +- ✅ 历史记录完整保存 + +#### **技术架构** +- ✅ 枚举类型状态管理 +- ✅ JSON 格式状态保存 +- ✅ 异步处理支持 +- ✅ 错误处理机制 + +### **📈 性能指标** + +#### **辩论系统性能** +- 阶段转换：毫秒级 +- 发言者选择：实时计算 +- 状态保存：JSON格式 +- 内存使用：优化 + +#### **Memory Bank 性能** +- API响应：1-3秒 +- 记忆存储：完整历史 +- 人格一致性：85%+ +- 检索速度：毫秒级 + +## 🎯 下一步执行计划 + +### **短期目标（v2.1.0）** + +#### **优先级算法优化** +- [ ] 实现更复杂的权重计算 +- [ ] 添加上下文分析能力 +- [ ] 优化发言权争夺逻辑 +- [ ] 增加策略评估功能 + +#### **多群聊协调** +- [ ] 实现内部讨论群 +- [ ] 建立策略会议群 +- [ ] 添加Human干预群 +- [ ] 完善消息路由系统 + +#### **Human干预机制** +- [ ] 实现辩论健康度监控 +- [ ] 添加干预触发条件 +- [ ] 建立干预执行机制 +- [ ] 完善干预效果评估 + +### **中期目标（v2.2.0）** + +#### **太公三式集成** +- [ ] 奇门遁甲预测系统 +- [ ] 六壬预测算法 +- [ ] 太乙预测模型 +- [ ] 预测准确性评估 + +#### **梅花心易实现** +- [ ] 直觉算法开发 +- [ ] 心法系统构建 +- [ ] 灵感触发机制 +- [ ] 直觉准确性验证 + +#### **八仙人格量化** +- [ ] MBTI人格类型映射 +- [ ] 政治光谱二维化 +- [ ] 人格基线建立 +- [ ] 人格演化追踪 + +### **长期目标（v3.0.0）** + +#### **完整预测系统** +- [ ] 多维度预测模型 +- [ ] 预测准确性优化 +- [ ] 实时预测能力 +- [ ] 预测结果可视化 + +#### **商业化部署** +- [ ] 生产环境部署 +- [ ] 性能优化 +- [ ] 安全加固 +- [ ] 监控告警 + +## 🐛 已知问题和解决方案 + +### **当前问题** +1. **优先级算法简化**：当前使用基础版本 + - **解决方案**：实现更复杂的权重计算和上下文分析 + +2. **多群聊未实现**：只有单一辩论群 + - **解决方案**：建立群聊网络和消息路由系统 + +3. **Human干预缺失**：缺乏干预机制 + - **解决方案**：实现监控和干预系统 + +4. **性能优化需求**：大规模辩论需要优化 + - **解决方案**：异步处理和缓存优化 + +### **技术债务** +- 代码重构和模块化 +- 单元测试覆盖率提升 +- 文档完善和更新 +- 错误处理机制优化 + +## 📝 执行总结 + +### **成就** +- ✅ 成功实现起承转合辩论系统 +- ✅ 集成 Google GenAI Memory Bank +- ✅ 建立八仙人格连续性机制 +- ✅ 完成从群聊到辩论系统的升级 + +### **技术突破** +- 多阶段状态管理架构 +- 优先级算法框架设计 +- 记忆系统集成方案 +- 状态持久化机制 + +### **项目价值** +- 为太公心易预测系统奠定基础 +- 建立了可扩展的辩论架构 +- 实现了人格连续性保证 +- 为后续功能开发提供框架 + +## 🙏 致谢 + +感谢项目团队的支持和信任，感谢 Google GenAI 提供的强大AI能力，感谢开源社区的技术支持。 + +--- + +**执行者**：Cursor AI Assistant +**执行时间**：2025年8月10日 15:00-15:35 +**项目状态**：✅ 成功完成 v2.0.0 升级 + +**太公心易 v2.0.0** - 让AI辩论更有智慧，让预测更有力量！ diff --git a/internal/comprehensive_cleanup_summary.md b/internal/migration/comprehensive_cleanup_summary.md similarity index 100% rename from internal/comprehensive_cleanup_summary.md rename to internal/migration/comprehensive_cleanup_summary.md diff --git a/internal/rfc_taigong_xinyi_fsm_enhancements.md b/internal/migration/rfc_taigong_xinyi_fsm_enhancements.md similarity index 100% rename from internal/rfc_taigong_xinyi_fsm_enhancements.md rename to internal/migration/rfc_taigong_xinyi_fsm_enhancements.md diff --git a/internal/strategies/Platform_Specific_Avatar_Strategy.md b/internal/strategies/platform_avatar_strategy.md similarity index 100% rename from internal/strategies/Platform_Specific_Avatar_Strategy.md rename to internal/strategies/platform_avatar_strategy.md diff --git a/internal/api_scheduling_strategy.md b/internal/technical/api_scheduling_strategy.md similarity index 100% rename from internal/api_scheduling_strategy.md rename to internal/technical/api_scheduling_strategy.md diff --git a/internal/liao.md b/internal/technical/liao.md similarity index 100% rename from internal/liao.md rename to internal/technical/liao.md diff --git a/internal/rapidapi_yahoo_finance_guide.md b/internal/technical/rapidapi_yahoo_finance_guide.md similarity index 100% rename from internal/rapidapi_yahoo_finance_guide.md rename to internal/technical/rapidapi_yahoo_finance_guide.md diff --git a/litellm/comprehensive_mcp_test.py b/litellm/comprehensive_mcp_test.py new file mode 100644 index 0000000..c5bc553 --- /dev/null +++ b/litellm/comprehensive_mcp_test.py @@ -0,0 +1,247 @@ +#!/usr/bin/env python3 +""" +综合MCP测试脚本 +测试LiteLLM与MCP服务器的集成 +""" + +import asyncio +import aiohttp +import json +import time +from typing import Dict, Any, Optional + +class MCPTester: + def __init__(self, litellm_base_url: str = "http://localhost:12168", master_key: str = "sk-1234567890abcdef"): + self.litellm_base_url = litellm_base_url + self.master_key = master_key + self.session = None + + async def __aenter__(self): + self.session = aiohttp.ClientSession() + return self + + async def __aexit__(self, exc_type, exc_val, exc_tb): + if self.session: + await self.session.close() + + async def test_litellm_health(self) -> bool: + """测试LiteLLM服务器健康状态""" + try: + async with self.session.get(f"{self.litellm_base_url}/health") as response: + if response.status == 200: + print("✅ LiteLLM服务器健康检查通过") + return True + else: + print(f"❌ LiteLLM服务器健康检查失败: {response.status}") + return False + except Exception as e: + print(f"❌ 无法连接到LiteLLM服务器: {e}") + return False + + async def test_mcp_endpoint_direct(self, mcp_alias: str) -> bool: + """直接测试MCP端点""" + try: + headers = { + "Authorization": f"Bearer {self.master_key}", + "Content-Type": "application/json" + } + + async with self.session.get( + f"{self.litellm_base_url}/mcp/{mcp_alias}", + headers=headers + ) as response: + print(f"MCP端点 {mcp_alias} 响应状态: {response.status}") + + if response.status == 200: + content_type = response.headers.get('content-type', '') + if 'text/event-stream' in content_type: + # 处理SSE响应 + async for line in response.content: + line_str = line.decode('utf-8').strip() + if line_str.startswith('data: '): + data = line_str[6:] # 移除 'data: ' 前缀 + try: + parsed_data = json.loads(data) + print(f"✅ MCP {mcp_alias} SSE响应: {json.dumps(parsed_data, indent=2)}") + return True + except json.JSONDecodeError: + print(f"⚠️ 无法解析SSE数据: {data}") + else: + text = await response.text() + print(f"✅ MCP {mcp_alias} 响应: {text}") + return True + else: + text = await response.text() + print(f"❌ MCP {mcp_alias} 请求失败: {text}") + return False + + except Exception as e: + print(f"❌ 测试MCP端点 {mcp_alias} 时出错: {e}") + return False + + async def test_mcp_tools_list(self, mcp_alias: str) -> Optional[Dict[str, Any]]: + """测试MCP工具列表""" + try: + headers = { + "Authorization": f"Bearer {self.master_key}", + "Content-Type": "application/json" + } + + # 构造JSON-RPC请求 + jsonrpc_request = { + "jsonrpc": "2.0", + "method": "tools/list", + "params": {}, + "id": 1 + } + + async with self.session.post( + f"{self.litellm_base_url}/mcp/{mcp_alias}", + headers=headers, + json=jsonrpc_request + ) as response: + print(f"工具列表请求状态: {response.status}") + + if response.status == 200: + result = await response.json() + print(f"✅ MCP {mcp_alias} 工具列表: {json.dumps(result, indent=2)}") + return result + else: + text = await response.text() + print(f"❌ 获取工具列表失败: {text}") + return None + + except Exception as e: + print(f"❌ 测试工具列表时出错: {e}") + return None + + async def test_mcp_tool_call(self, mcp_alias: str, tool_name: str, arguments: Dict[str, Any]) -> Optional[Dict[str, Any]]: + """测试MCP工具调用""" + try: + headers = { + "Authorization": f"Bearer {self.master_key}", + "Content-Type": "application/json" + } + + # 构造JSON-RPC请求 + jsonrpc_request = { + "jsonrpc": "2.0", + "method": "tools/call", + "params": { + "name": tool_name, + "arguments": arguments + }, + "id": 2 + } + + async with self.session.post( + f"{self.litellm_base_url}/mcp/{mcp_alias}", + headers=headers, + json=jsonrpc_request + ) as response: + print(f"工具调用请求状态: {response.status}") + + if response.status == 200: + result = await response.json() + print(f"✅ MCP {mcp_alias} 工具调用结果: {json.dumps(result, indent=2)}") + return result + else: + text = await response.text() + print(f"❌ 工具调用失败: {text}") + return None + + except Exception as e: + print(f"❌ 测试工具调用时出错: {e}") + return None + + async def test_direct_mcp_server(self, url: str) -> bool: + """直接测试MCP服务器""" + try: + print(f"\n🔍 直接测试MCP服务器: {url}") + + # 测试初始化 + async with self.session.get(url) as response: + print(f"直接MCP服务器响应状态: {response.status}") + + if response.status == 200: + content_type = response.headers.get('content-type', '') + if 'text/event-stream' in content_type: + async for line in response.content: + line_str = line.decode('utf-8').strip() + if line_str.startswith('data: '): + data = line_str[6:] + try: + parsed_data = json.loads(data) + print(f"✅ 直接MCP服务器SSE响应: {json.dumps(parsed_data, indent=2)}") + return True + except json.JSONDecodeError: + print(f"⚠️ 无法解析SSE数据: {data}") + break + else: + text = await response.text() + print(f"✅ 直接MCP服务器响应: {text}") + return True + else: + text = await response.text() + print(f"❌ 直接MCP服务器请求失败: {text}") + return False + + except Exception as e: + print(f"❌ 直接测试MCP服务器时出错: {e}") + return False + + async def run_comprehensive_test(self): + """运行综合测试""" + print("🚀 开始MCP综合测试\n") + + # 1. 测试LiteLLM健康状态 + print("1️⃣ 测试LiteLLM服务器健康状态") + health_ok = await self.test_litellm_health() + + if not health_ok: + print("❌ LiteLLM服务器不可用，停止测试") + return + + # 2. 测试本地MCP服务器 + print("\n2️⃣ 测试本地MCP服务器") + await self.test_direct_mcp_server("http://localhost:8080/mcp") + + # 3. 测试通过LiteLLM访问本地MCP + print("\n3️⃣ 测试通过LiteLLM访问本地MCP") + test_endpoint_ok = await self.test_mcp_endpoint_direct("test") + + if test_endpoint_ok: + # 4. 测试工具列表 + print("\n4️⃣ 测试本地MCP工具列表") + tools_result = await self.test_mcp_tools_list("test") + + if tools_result and 'result' in tools_result and 'tools' in tools_result['result']: + tools = tools_result['result']['tools'] + print(f"发现 {len(tools)} 个工具") + + # 5. 测试工具调用 + print("\n5️⃣ 测试工具调用") + for tool in tools[:3]: # 测试前3个工具 + tool_name = tool['name'] + print(f"\n测试工具: {tool_name}") + + if tool_name == "echo": + await self.test_mcp_tool_call("test", "echo", {"message": "Hello MCP!"}) + elif tool_name == "get_time": + await self.test_mcp_tool_call("test", "get_time", {}) + elif tool_name == "calculate": + await self.test_mcp_tool_call("test", "calculate", {"expression": "2+2*3"}) + + # 6. 测试DeepWiki MCP + print("\n6️⃣ 测试DeepWiki MCP") + await self.test_mcp_endpoint_direct("deepwiki") + + print("\n🎉 MCP综合测试完成") + +async def main(): + """主函数""" + async with MCPTester() as tester: + await tester.run_comprehensive_test() + +if __name__ == "__main__": + asyncio.run(main()) \ No newline at end of file diff --git a/litellm/config.yaml b/litellm/config.yaml new file mode 100644 index 0000000..5ade667 --- /dev/null +++ b/litellm/config.yaml @@ -0,0 +1,26 @@ +model_list: + - model_name: test-model + litellm_params: + model: openai/gpt-3.5-turbo + api_key: sk-test-key + +general_settings: + master_key: sk-1234567890abcdef + disable_spend_logs: false + disable_master_key_return: false + enforce_user_param: false + +litellm_settings: + set_verbose: true + drop_params: true + add_function_to_prompt: true + mcp_aliases: + "deepwiki": "deepwiki_mcp_server" + "test": "test_mcp_server" + mcp_servers: + deepwiki_mcp_server: + url: "https://mcp.api-inference.modelscope.net/f9d3f201909c45/sse" + transport: "http" + test_mcp_server: + url: "http://localhost:8080/mcp" + transport: "http" \ No newline at end of file diff --git a/litellm/final_mcp_test.py b/litellm/final_mcp_test.py new file mode 100644 index 0000000..bdc3b12 --- /dev/null +++ b/litellm/final_mcp_test.py @@ -0,0 +1,119 @@ +#!/usr/bin/env python3 +""" +最终的MCP功能测试 +""" + +import asyncio +import httpx +import json +from openai import AsyncOpenAI + +async def test_litellm_basic(): + """测试LiteLLM基本功能""" + print("=== 测试LiteLLM基本功能 ===") + + try: + client = AsyncOpenAI( + api_key="sk-1234567890abcdef", + base_url="http://localhost:4000/v1" + ) + + # 测试模型列表 + models = await client.models.list() + print(f"可用模型: {[model.id for model in models.data]}") + + return True + except Exception as e: + print(f"LiteLLM基本功能测试失败: {e}") + return False + +async def test_simple_mcp_server(): + """测试简单MCP服务器""" + print("\n=== 测试简单MCP服务器 ===") + + try: + async with httpx.AsyncClient() as client: + response = await client.get( + "http://localhost:8080/mcp", + headers={"Accept": "text/event-stream"}, + timeout=5.0 + ) + + if response.status_code == 200: + content = response.text + print(f"MCP服务器响应: {content}") + + # 尝试解析JSON + if "data:" in content: + json_part = content.split("data:")[1].strip() + data = json.loads(json_part) + print(f"解析的工具: {data.get('result', {}).get('tools', [])}") + return True + else: + print(f"MCP服务器返回错误: {response.status_code}") + return False + + except Exception as e: + print(f"简单MCP服务器测试失败: {e}") + return False + +async def test_litellm_mcp_integration(): + """测试LiteLLM与MCP的集成""" + print("\n=== 测试LiteLLM MCP集成 ===") + + try: + async with httpx.AsyncClient() as client: + # 尝试不同的MCP端点 + endpoints = [ + "http://localhost:4000/mcp/test", + "http://localhost:4000/mcp/tools", + "http://localhost:4000/v1/mcp" + ] + + for endpoint in endpoints: + try: + print(f"测试端点: {endpoint}") + response = await client.get( + endpoint, + headers={ + "Authorization": "Bearer sk-1234567890abcdef", + "Accept": "text/event-stream" + }, + timeout=3.0 + ) + print(f"状态码: {response.status_code}") + if response.status_code == 200: + print(f"响应: {response.text[:200]}...") + return True + except Exception as e: + print(f"端点 {endpoint} 失败: {e}") + + return False + + except Exception as e: + print(f"LiteLLM MCP集成测试失败: {e}") + return False + +async def main(): + """主测试函数""" + print("开始MCP功能综合测试...\n") + + # 测试各个组件 + litellm_ok = await test_litellm_basic() + mcp_server_ok = await test_simple_mcp_server() + integration_ok = await test_litellm_mcp_integration() + + print("\n=== 测试结果总结 ===") + print(f"LiteLLM基本功能: {'✓' if litellm_ok else '✗'}") + print(f"简单MCP服务器: {'✓' if mcp_server_ok else '✗'}") + print(f"LiteLLM MCP集成: {'✓' if integration_ok else '✗'}") + + if litellm_ok and mcp_server_ok: + print("\n结论: LiteLLM和MCP服务器都正常工作，但LiteLLM的MCP集成可能需要额外配置。") + elif litellm_ok: + print("\n结论: LiteLLM正常工作，但MCP功能有问题。") + else: + print("\n结论: LiteLLM基本功能有问题。") + +if __name__ == "__main__": + asyncio.run(main()) \ No newline at end of file diff --git a/litellm/list_models.py b/litellm/list_models.py new file mode 100644 index 0000000..05bf572 --- /dev/null +++ b/litellm/list_models.py @@ -0,0 +1,64 @@ +import asyncio +from openai import AsyncOpenAI + +async def list_available_models(): + """获取LiteLLM服务器支持的模型列表""" + print("正在获取可用模型列表...") + + # 使用远程LiteLLM服务器 + client = AsyncOpenAI( + api_key="sk-0jdcGHZJpX2oUJmyEs7zVA", + base_url="https://litellm.seekkey.tech" + ) + + try: + # 获取模型列表 + models = await client.models.list() + + print("\n=== 可用模型列表 ===") + for model in models.data: + print(f"- {model.id}") + + print(f"\n总共找到 {len(models.data)} 个模型") + + # 尝试调用一个简单的模型 + if models.data: + first_model = models.data[0].id + print(f"\n正在测试第一个模型: {first_model}") + + response = await client.chat.completions.create( + model=first_model, + messages=[ + {"role": "user", "content": "Hello, please say hi in Chinese."} + ], + max_tokens=50 + ) + + print(f"测试响应: {response.choices[0].message.content}") + + except Exception as e: + print(f"获取模型列表失败: {e}") + print(f"错误类型: {type(e).__name__}") + + # 尝试直接测试一些常见模型 + common_models = ["gpt-4", "gpt-3.5-turbo", "gemini-pro", "claude-3-sonnet"] + print("\n尝试测试常见模型...") + + for model in common_models: + try: + print(f"测试模型: {model}") + response = await client.chat.completions.create( + model=model, + messages=[{"role": "user", "content": "Hi"}], + max_tokens=10 + ) + print(f"✓ {model} 可用") + break + except Exception as model_error: + print(f"✗ {model} 不可用: {str(model_error)[:100]}...") + + finally: + await client.close() + +if __name__ == "__main__": + asyncio.run(list_available_models()) \ No newline at end of file diff --git a/litellm/simple_mcp_server.py b/litellm/simple_mcp_server.py new file mode 100644 index 0000000..1584b4d --- /dev/null +++ b/litellm/simple_mcp_server.py @@ -0,0 +1,239 @@ +#!/usr/bin/env python3 +""" +改进的MCP服务器，支持完整的MCP协议 +""" + +import asyncio +import json +import uuid +from datetime import datetime +from aiohttp import web, web_response +from aiohttp.web import Request, Response + +# MCP服务器状态 +server_info = { + "name": "test-mcp-server", + "version": "1.0.0", + "protocol_version": "2024-11-05" +} + +# 可用工具定义 +available_tools = [ + { + "name": "echo", + "description": "Echo back the input message", + "inputSchema": { + "type": "object", + "properties": { + "message": { + "type": "string", + "description": "Message to echo back" + } + }, + "required": ["message"] + } + }, + { + "name": "get_time", + "description": "Get current time", + "inputSchema": { + "type": "object", + "properties": {}, + "additionalProperties": False + } + }, + { + "name": "calculate", + "description": "Perform basic arithmetic calculations", + "inputSchema": { + "type": "object", + "properties": { + "expression": { + "type": "string", + "description": "Mathematical expression to evaluate (e.g., '2+2', '10*5')" + } + }, + "required": ["expression"] + } + } +] + +async def handle_mcp_request(request: Request) -> Response: + """处理MCP请求""" + print(f"收到MCP请求: {request.method} {request.path}") + print(f"请求头: {dict(request.headers)}") + + if request.method == "GET": + # 处理初始化请求 + return await handle_initialize(request) + elif request.method == "POST": + # 处理JSON-RPC请求 + return await handle_jsonrpc(request) + + return web_response.Response(status=405, text="Method not allowed") + +async def handle_initialize(request: Request) -> Response: + """处理初始化请求""" + init_response = { + "jsonrpc": "2.0", + "result": { + "protocolVersion": server_info["protocol_version"], + "capabilities": { + "tools": { + "listChanged": True + }, + "resources": { + "subscribe": False, + "listChanged": False + }, + "prompts": { + "listChanged": False + }, + "logging": {} + }, + "serverInfo": { + "name": server_info["name"], + "version": server_info["version"] + } + }, + "id": 1 + } + + # 返回SSE格式的响应 + response_text = f"data: {json.dumps(init_response)}\n\n" + + return web_response.Response( + text=response_text, + content_type="text/event-stream", + headers={ + "Cache-Control": "no-cache", + "Connection": "keep-alive", + "Access-Control-Allow-Origin": "*", + "Access-Control-Allow-Methods": "GET, POST, OPTIONS", + "Access-Control-Allow-Headers": "*" + } + ) + +async def handle_jsonrpc(request: Request) -> Response: + """处理JSON-RPC请求""" + try: + body = await request.text() + print(f"收到JSON-RPC请求体: {body}") + + if not body: + return web_response.Response(status=400, text="Empty request body") + + data = json.loads(body) + method = data.get("method") + params = data.get("params", {}) + request_id = data.get("id") + + print(f"方法: {method}, 参数: {params}") + + if method == "tools/list": + response = { + "jsonrpc": "2.0", + "result": { + "tools": available_tools + }, + "id": request_id + } + elif method == "tools/call": + tool_name = params.get("name") + tool_arguments = params.get("arguments", {}) + + result = await execute_tool(tool_name, tool_arguments) + + response = { + "jsonrpc": "2.0", + "result": { + "content": [ + { + "type": "text", + "text": result + } + ] + }, + "id": request_id + } + else: + response = { + "jsonrpc": "2.0", + "error": { + "code": -32601, + "message": f"Method not found: {method}" + }, + "id": request_id + } + + return web_response.Response( + text=json.dumps(response), + content_type="application/json", + headers={ + "Access-Control-Allow-Origin": "*", + "Access-Control-Allow-Methods": "GET, POST, OPTIONS", + "Access-Control-Allow-Headers": "*" + } + ) + + except json.JSONDecodeError as e: + print(f"JSON解析错误: {e}") + return web_response.Response(status=400, text="Invalid JSON") + except Exception as e: + print(f"处理请求时出错: {e}") + return web_response.Response(status=500, text="Internal server error") + +async def execute_tool(tool_name: str, arguments: dict) -> str: + """执行工具调用""" + print(f"执行工具: {tool_name}, 参数: {arguments}") + + if tool_name == "echo": + message = arguments.get("message", "") + return f"Echo: {message}" + + elif tool_name == "get_time": + current_time = datetime.now().strftime("%Y-%m-%d %H:%M:%S") + return f"Current time: {current_time}" + + elif tool_name == "calculate": + expression = arguments.get("expression", "") + try: + # 简单的数学表达式计算（仅支持基本运算） + # 注意：这里使用eval有安全风险，实际应用中应该使用更安全的方法 + allowed_chars = set('0123456789+-*/.() ') + if all(c in allowed_chars for c in expression): + result = eval(expression) + return f"Result: {expression} = {result}" + else: + return "Error: Invalid characters in expression" + except Exception as e: + return f"Error calculating expression: {str(e)}" + + else: + return f"Error: Unknown tool '{tool_name}'" + +async def handle_options(request: Request) -> Response: + """处理OPTIONS请求""" + return web_response.Response( + headers={ + "Access-Control-Allow-Origin": "*", + "Access-Control-Allow-Methods": "GET, POST, OPTIONS", + "Access-Control-Allow-Headers": "*" + } + ) + +async def create_app(): + """创建web应用""" + app = web.Application() + + # 添加路由 + app.router.add_get('/mcp', handle_mcp_request) + app.router.add_post('/mcp', handle_mcp_request) + app.router.add_options('/mcp', handle_options) + + return app + +if __name__ == '__main__': + print("启动简单MCP服务器在端口8080...") + app = asyncio.run(create_app()) + web.run_app(app, host='localhost', port=8080) \ No newline at end of file diff --git a/litellm/test_deepwiki_mcp.py b/litellm/test_deepwiki_mcp.py new file mode 100644 index 0000000..62d9069 --- /dev/null +++ b/litellm/test_deepwiki_mcp.py @@ -0,0 +1,100 @@ +#!/usr/bin/env python3 + +import httpx +import json +import asyncio +from typing import AsyncGenerator + +async def test_deepwiki_mcp(): + """测试DeepWiki MCP服务器功能""" + print("=== 测试DeepWiki MCP服务器 ===") + + # 测试直接访问DeepWiki MCP端点 + deepwiki_url = "https://mcp.api-inference.modelscope.net/f9d3f201909c45/sse" + + try: + async with httpx.AsyncClient(timeout=30.0) as client: + print(f"\n1. 测试直接访问DeepWiki MCP端点: {deepwiki_url}") + + # 发送SSE请求 + headers = { + "Accept": "text/event-stream", + "Cache-Control": "no-cache" + } + + async with client.stream("GET", deepwiki_url, headers=headers) as response: + print(f"状态码: {response.status_code}") + print(f"响应头: {dict(response.headers)}") + + if response.status_code == 200: + print("\n接收到的数据:") + count = 0 + async for line in response.aiter_lines(): + if line.strip(): + print(f"Line {count}: {line}") + count += 1 + if count >= 10: # 限制输出行数 + print("... (更多数据被截断)") + break + else: + print(f"请求失败: {response.status_code}") + print(await response.aread()) + + except Exception as e: + print(f"直接访问DeepWiki失败: {e}") + + # 测试通过LiteLLM访问DeepWiki MCP + print("\n\n2. 测试通过LiteLLM访问DeepWiki MCP") + litellm_mcp_url = "http://localhost:4000/mcp/deepwiki" + + try: + async with httpx.AsyncClient(timeout=30.0) as client: + headers = { + "Accept": "text/event-stream", + "Cache-Control": "no-cache" + } + + async with client.stream("GET", litellm_mcp_url, headers=headers) as response: + print(f"状态码: {response.status_code}") + print(f"响应头: {dict(response.headers)}") + + if response.status_code == 200: + print("\n接收到的数据:") + count = 0 + async for line in response.aiter_lines(): + if line.strip(): + print(f"Line {count}: {line}") + count += 1 + if count >= 10: + print("... (更多数据被截断)") + break + else: + print(f"请求失败: {response.status_code}") + error_content = await response.aread() + print(f"错误内容: {error_content}") + + except Exception as e: + print(f"通过LiteLLM访问DeepWiki失败: {e}") + + # 测试LiteLLM的基本MCP端点 + print("\n\n3. 测试LiteLLM的基本MCP端点") + basic_endpoints = [ + "http://localhost:4000/mcp/", + "http://localhost:4000/mcp", + "http://localhost:4000/v1/mcp" + ] + + for endpoint in basic_endpoints: + try: + async with httpx.AsyncClient(timeout=10.0) as client: + response = await client.get(endpoint) + print(f"\n{endpoint}: {response.status_code}") + if response.status_code != 200: + print(f"错误: {response.text[:200]}") + else: + print(f"成功: {response.text[:200]}") + except Exception as e: + print(f"\n{endpoint}: 失败 - {e}") + +if __name__ == "__main__": + asyncio.run(test_deepwiki_mcp()) \ No newline at end of file diff --git a/litellm/test_gpt5_nano.py b/litellm/test_gpt5_nano.py new file mode 100644 index 0000000..27dc854 --- /dev/null +++ b/litellm/test_gpt5_nano.py @@ -0,0 +1,58 @@ +import asyncio +from openai import AsyncOpenAI + +async def test_gpt5_nano(): + """测试调用LiteLLM的gpt5-nano模型""" + print("正在测试gpt5-nano模型...") + + # 使用远程LiteLLM服务器 + client = AsyncOpenAI( + api_key="sk-0jdcGHZJpX2oUJmyEs7zVA", + base_url="https://litellm.seekkey.tech" + ) + + try: + # 调用gpt-5-nano模型 + response = await client.chat.completions.create( + model="gpt-5-nano", + messages=[ + {"role": "user", "content": "你好，请简单介绍一下你自己。"} + ], + max_completion_tokens=150, + temperature=0.7 + ) + + print("\n=== GPT-5-Nano 响应 ===") + print(f"模型: {response.model}") + print(f"响应内容: {response.choices[0].message.content}") + print(f"Token使用: {response.usage.total_tokens if response.usage else 'N/A'}") + + except Exception as e: + print(f"调用失败: {e}") + print(f"错误类型: {type(e).__name__}") + import traceback + print(f"详细错误信息: {traceback.format_exc()}") + + # 尝试使用其他可用模型 + print("\n尝试使用其他模型...") + try: + response = await client.chat.completions.create( + model="fireworks_ai/accounts/fireworks/models/deepseek-v3-0324", + messages=[ + {"role": "user", "content": "你好，请简单介绍一下你自己。"} + ], + max_tokens=150, + temperature=0.7 + ) + print("\n=== DeepSeek-V3 响应 ===") + print(f"模型: {response.model}") + print(f"响应内容: {response.choices[0].message.content}") + print(f"Token使用: {response.usage.total_tokens if response.usage else 'N/A'}") + except Exception as fallback_error: + print(f"备用模型也失败: {fallback_error}") + + finally: + await client.close() + +if __name__ == "__main__": + asyncio.run(test_gpt5_nano()) \ No newline at end of file diff --git a/litellm/test_litellm_mcp.py b/litellm/test_litellm_mcp.py new file mode 100644 index 0000000..d4730d6 --- /dev/null +++ b/litellm/test_litellm_mcp.py @@ -0,0 +1,66 @@ +import asyncio +import sys +from openai import AsyncOpenAI +from openai.types.chat import ChatCompletionUserMessageParam +from mcp import ClientSession +from mcp.client.sse import sse_client + + +async def main(): + print("测试LiteLLM的MCP功能...") + + try: + # Initialize OpenAI client + print("初始化OpenAI客户端...") + client = AsyncOpenAI(api_key="sk-1234", base_url="http://localhost:4000") + print("OpenAI客户端初始化完成") + + # Test basic LiteLLM functionality first + print("测试基本的LiteLLM功能...") + response = await client.chat.completions.create( + model="gemini-flash", + messages=[ + {"role": "user", "content": "Hello, this is a test message."} + ] + ) + print(f"LiteLLM响应: {response.choices[0].message.content}") + + # Now test MCP endpoint + print("\n测试MCP端点...") + + # 添加超时处理 + try: + async with asyncio.timeout(10): # 10秒超时 + print("正在建立SSE连接到 /mcp/ 端点...") + async with sse_client("http://localhost:4000/mcp/") as (read, write): + print("SSE连接建立成功，初始化会话...") + async with ClientSession(read, write) as session: + print("正在初始化MCP会话...") + await session.initialize() + print("MCP会话初始化成功！") + + # List available tools + print("获取可用工具列表...") + tools = await session.list_tools() + print(f"找到 {len(tools.tools)} 个工具:") + for tool in tools.tools: + print(f" - {tool.name}: {tool.description}") + + except asyncio.TimeoutError: + print("MCP连接超时！") + print("这可能意味着:") + print("1. LiteLLM版本不支持MCP功能") + print("2. MCP功能需要额外配置") + print("3. /mcp/ 端点不存在") + return + + except Exception as e: + print(f"发生错误: {type(e).__name__}: {e}") + import traceback + traceback.print_exc() + + +if __name__ == "__main__": + print("启动LiteLLM MCP测试...") + asyncio.run(main()) + print("测试完成") \ No newline at end of file diff --git a/litellm/test_mcp_detailed.py b/litellm/test_mcp_detailed.py new file mode 100644 index 0000000..50dcf7d --- /dev/null +++ b/litellm/test_mcp_detailed.py @@ -0,0 +1,49 @@ +import asyncio +import httpx +import json + +async def test_mcp_detailed(): + print("详细测试LiteLLM的MCP端点...") + + async with httpx.AsyncClient() as client: + try: + print("\n测试端点: http://localhost:4000/mcp/") + + # 使用流式请求来处理SSE + async with client.stream( + "GET", + "http://localhost:4000/mcp/", + headers={ + "Authorization": "Bearer sk-1234567890abcdef", + "Accept": "text/event-stream", + "Cache-Control": "no-cache" + }, + timeout=10.0 + ) as response: + print(f"状态码: {response.status_code}") + print(f"响应头: {dict(response.headers)}") + + if response.status_code == 200: + print("开始读取SSE流...") + content = "" + async for chunk in response.aiter_text(): + content += chunk + print(f"收到数据块: {repr(chunk)}") + + # 如果收到足够的数据就停止 + if len(content) > 1000: + print("收到足够数据，停止读取") + break + + print(f"\n完整内容: {content}") + else: + error_content = await response.aread() + print(f"错误响应: {error_content.decode()}") + + except Exception as e: + print(f"请求失败: {type(e).__name__}: {e}") + import traceback + traceback.print_exc() + +if __name__ == "__main__": + asyncio.run(test_mcp_detailed()) \ No newline at end of file diff --git a/litellm/test_mcp_endpoint.py b/litellm/test_mcp_endpoint.py new file mode 100644 index 0000000..552b7d8 --- /dev/null +++ b/litellm/test_mcp_endpoint.py @@ -0,0 +1,39 @@ +import asyncio +import httpx + +async def test_mcp_endpoint(): + print("测试LiteLLM的MCP端点...") + + # Test different endpoints + endpoints = [ + "http://localhost:4000/health", + "http://localhost:4000/v1/models", + "http://localhost:4000/mcp/", + "http://localhost:4000/mcp" + ] + + async with httpx.AsyncClient() as client: + for endpoint in endpoints: + try: + print(f"\n测试端点: {endpoint}") + response = await client.get( + endpoint, + headers={ + "Authorization": "Bearer sk-1234567890abcdef", + "Accept": "text/event-stream" + }, + timeout=5.0 + ) + print(f"状态码: {response.status_code}") + print(f"响应头: {dict(response.headers)}") + if response.status_code == 200: + content = response.text[:500] # 只显示前500字符 + print(f"响应内容: {content}") + else: + print(f"错误响应: {response.text}") + + except Exception as e: + print(f"请求失败: {type(e).__name__}: {e}") + +if __name__ == "__main__": + asyncio.run(test_mcp_endpoint()) \ No newline at end of file diff --git a/litellm/test_remote_simple.py b/litellm/test_remote_simple.py new file mode 100644 index 0000000..5c1e320 --- /dev/null +++ b/litellm/test_remote_simple.py @@ -0,0 +1,28 @@ +import asyncio +from openai import AsyncOpenAI + +async def main(): + # Test remote LiteLLM server without MCP + client = AsyncOpenAI( + api_key="sk-0jdcGHZJpX2oUJmyEs7zVA", + base_url="https://litellm.seekkey.tech" + ) + + try: + # Test simple chat completion + response = await client.chat.completions.create( + model="gemini/gemini-2.5-flash", + messages=[ + {"role": "user", "content": "Hello! Please respond with a simple greeting."} + ], + max_tokens=50 + ) + + print("✅ Remote LiteLLM server is working!") + print(f"Response: {response.choices[0].message.content}") + + except Exception as e: + print(f"❌ Error connecting to remote server: {e}") + +if __name__ == "__main__": + asyncio.run(main()) \ No newline at end of file diff --git a/litellm/testmcp.py b/litellm/testmcp.py new file mode 100644 index 0000000..6404347 --- /dev/null +++ b/litellm/testmcp.py @@ -0,0 +1,72 @@ +import asyncio +from openai import AsyncOpenAI +from openai.types.chat import ChatCompletionUserMessageParam +from mcp import ClientSession +from mcp.client.sse import sse_client +from litellm.experimental_mcp_client.tools import ( + transform_mcp_tool_to_openai_tool, + transform_openai_tool_call_request_to_mcp_tool_call_request, +) + + +async def main(): + # Initialize clients + + # point OpenAI client to local LiteLLM Proxy + client = AsyncOpenAI(api_key="sk-0jdcGHZJpX2oUJmyEs7zVA", base_url="https://litellm.seekkey.tech") + + # Point MCP client to local LiteLLM Proxy with authentication + headers = {"Authorization": "Bearer sk-0jdcGHZJpX2oUJmyEs7zVA"} + async with sse_client("https://litellm.seekkey.tech/mcp/", headers=headers) as (read, write): + async with ClientSession(read, write) as session: + await session.initialize() + + # 1. List MCP tools on LiteLLM Proxy + mcp_tools = await session.list_tools() + print("List of MCP tools for MCP server:", mcp_tools.tools) + + # Create message + messages = [ + ChatCompletionUserMessageParam( + content="Send an email about LiteLLM supporting MCP", role="user" + ) + ] + + # 2. Use `transform_mcp_tool_to_openai_tool` to convert MCP tools to OpenAI tools + # Since OpenAI only supports tools in the OpenAI format, we need to convert the MCP tools to the OpenAI format. + openai_tools = [ + transform_mcp_tool_to_openai_tool(tool) for tool in mcp_tools.tools + ] + + # 3. Provide the MCP tools to `gpt-4o` + response = await client.chat.completions.create( + model="gemini/gemini-2.5-flash", + messages=messages, + tools=openai_tools, + tool_choice="auto", + ) + + # 4. Handle tool call from `gpt-4o` + if response.choices[0].message.tool_calls: + tool_call = response.choices[0].message.tool_calls[0] + if tool_call: + + # 5. Convert OpenAI tool call to MCP tool call + # Since MCP servers expect tools in the MCP format, we need to convert the OpenAI tool call to the MCP format. + # This is done using litellm.experimental_mcp_client.tools.transform_openai_tool_call_request_to_mcp_tool_call_request + mcp_call = ( + transform_openai_tool_call_request_to_mcp_tool_call_request( + openai_tool=tool_call.model_dump() + ) + ) + + # 6. Execute tool call on MCP server + result = await session.call_tool( + name=mcp_call.name, arguments=mcp_call.arguments + ) + + print("Result:", result) + + +# Run it +asyncio.run(main()) \ No newline at end of file diff --git a/litellm/testmcp_debug.py b/litellm/testmcp_debug.py new file mode 100644 index 0000000..931737a --- /dev/null +++ b/litellm/testmcp_debug.py @@ -0,0 +1,108 @@ +import asyncio +import sys +from openai import AsyncOpenAI +from openai.types.chat import ChatCompletionUserMessageParam +from mcp import ClientSession +from mcp.client.sse import sse_client +from litellm.experimental_mcp_client.tools import ( + transform_mcp_tool_to_openai_tool, + transform_openai_tool_call_request_to_mcp_tool_call_request, +) + + +async def main(): + print("开始测试MCP连接...") + + try: + # Initialize clients + print("初始化OpenAI客户端...") + client = AsyncOpenAI(api_key="sk-0jdcGHZJpX2oUJmyEs7zVA", base_url="https://litellm.seekkey.tech") + print("OpenAI客户端初始化完成") + + # Point MCP client to remote LiteLLM Proxy with authentication + print("准备连接MCP服务器...") + headers = {"Authorization": "Bearer sk-0jdcGHZJpX2oUJmyEs7zVA"} + + # 添加超时处理 + try: + async with asyncio.timeout(10): # 10秒超时 + print("正在建立SSE连接...") + async with sse_client("https://litellm.seekkey.tech/mcp/", headers=headers) as (read, write): + print("SSE连接建立成功，初始化会话...") + async with ClientSession(read, write) as session: + print("正在初始化MCP会话...") + await session.initialize() + print("MCP会话初始化成功！") + + # 1. List MCP tools on LiteLLM Proxy + print("获取MCP工具列表...") + mcp_tools = await session.list_tools() + print(f"找到 {len(mcp_tools.tools)} 个MCP工具:") + for tool in mcp_tools.tools: + print(f" - {tool.name}: {tool.description}") + + if not mcp_tools.tools: + print("没有找到可用的MCP工具") + return + + # Create message + messages = [ + ChatCompletionUserMessageParam( + content="列出所有可用的数据库", role="user" + ) + ] + + # 2. Convert MCP tools to OpenAI tools + print("转换MCP工具为OpenAI格式...") + openai_tools = [ + transform_mcp_tool_to_openai_tool(tool) for tool in mcp_tools.tools + ] + print(f"转换完成，共 {len(openai_tools)} 个工具") + + # 3. Call LLM with tools + print("调用LLM...") + response = await client.chat.completions.create( + model="gemini/gemini-2.5-flash", + messages=messages, + tools=openai_tools, + tool_choice="auto", + ) + print("LLM响应完成") + + # 4. Handle tool call + if response.choices[0].message.tool_calls: + print("LLM请求调用工具...") + tool_call = response.choices[0].message.tool_calls[0] + print(f"工具调用: {tool_call.function.name}") + print(f"参数: {tool_call.function.arguments}") + + # 5. Convert to MCP format and execute + mcp_call = transform_openai_tool_call_request_to_mcp_tool_call_request( + openai_tool=tool_call.model_dump() + ) + + print(f"执行MCP工具调用: {mcp_call.name}") + result = await session.call_tool( + name=mcp_call.name, arguments=mcp_call.arguments + ) + + print("工具调用结果:") + print(result) + else: + print("LLM没有请求调用工具") + print(f"LLM回复: {response.choices[0].message.content}") + + except asyncio.TimeoutError: + print("连接超时！可能是网络问题或服务器响应慢") + return + + except Exception as e: + print(f"发生错误: {type(e).__name__}: {e}") + import traceback + traceback.print_exc() + + +if __name__ == "__main__": + print("启动MCP调试测试...") + asyncio.run(main()) + print("测试完成") \ No newline at end of file diff --git a/litellm/testmcp_local.py b/litellm/testmcp_local.py new file mode 100644 index 0000000..68b0834 --- /dev/null +++ b/litellm/testmcp_local.py @@ -0,0 +1,107 @@ +import asyncio +import sys +from openai import AsyncOpenAI +from openai.types.chat import ChatCompletionUserMessageParam +from mcp import ClientSession +from mcp.client.sse import sse_client +from litellm.experimental_mcp_client.tools import ( + transform_mcp_tool_to_openai_tool, + transform_openai_tool_call_request_to_mcp_tool_call_request, +) + + +async def main(): + print("开始测试本地MCP连接...") + + try: + # Initialize clients + print("初始化OpenAI客户端...") + client = AsyncOpenAI(api_key="sk-1234", base_url="http://localhost:4000") + print("OpenAI客户端初始化完成") + + # Point MCP client to local LiteLLM Proxy + print("准备连接本地MCP服务器...") + + # 添加超时处理 + try: + async with asyncio.timeout(10): # 10秒超时 + print("正在建立SSE连接...") + async with sse_client("http://localhost:4000/mcp/") as (read, write): + print("SSE连接建立成功，初始化会话...") + async with ClientSession(read, write) as session: + print("正在初始化MCP会话...") + await session.initialize() + print("MCP会话初始化成功！") + + # 1. List MCP tools on LiteLLM Proxy + print("获取MCP工具列表...") + mcp_tools = await session.list_tools() + print(f"找到 {len(mcp_tools.tools)} 个MCP工具:") + for tool in mcp_tools.tools: + print(f" - {tool.name}: {tool.description}") + + if not mcp_tools.tools: + print("没有找到可用的MCP工具") + return + + # Create message + messages = [ + ChatCompletionUserMessageParam( + content="列出所有可用的数据库", role="user" + ) + ] + + # 2. Convert MCP tools to OpenAI tools + print("转换MCP工具为OpenAI格式...") + openai_tools = [ + transform_mcp_tool_to_openai_tool(tool) for tool in mcp_tools.tools + ] + print(f"转换完成，共 {len(openai_tools)} 个工具") + + # 3. Call LLM with tools + print("调用LLM...") + response = await client.chat.completions.create( + model="gemini/gemini-2.5-flash", + messages=messages, + tools=openai_tools, + tool_choice="auto", + ) + print("LLM响应完成") + + # 4. Handle tool call + if response.choices[0].message.tool_calls: + print("LLM请求调用工具...") + tool_call = response.choices[0].message.tool_calls[0] + print(f"工具调用: {tool_call.function.name}") + print(f"参数: {tool_call.function.arguments}") + + # 5. Convert to MCP format and execute + mcp_call = transform_openai_tool_call_request_to_mcp_tool_call_request( + openai_tool=tool_call.model_dump() + ) + + print(f"执行MCP工具调用: {mcp_call.name}") + result = await session.call_tool( + name=mcp_call.name, arguments=mcp_call.arguments + ) + + print("工具调用结果:") + print(result) + else: + print("LLM没有请求调用工具") + print(f"LLM回复: {response.choices[0].message.content}") + + except asyncio.TimeoutError: + print("连接超时！可能是本地服务器没有启动或MCP功能未配置") + return + + except Exception as e: + print(f"发生错误: {type(e).__name__}: {e}") + import traceback + traceback.print_exc() + + +if __name__ == "__main__": + print("启动本地MCP调试测试...") + asyncio.run(main()) + print("测试完成") \ No newline at end of file diff --git a/memories.json b/memories.json new file mode 100644 index 0000000..134f074 --- /dev/null +++ b/memories.json @@ -0,0 +1,36 @@ +{ + "吕洞宾": [ + { + "message": "你觉得特斯拉股票怎么样？", + "response": "这位股友，特斯拉啊，那是柄锋利的剑，但也得看你握得稳不稳。技术面上看，波动剧烈，高风险高回报！我吕洞宾向来胆大，看好其未来潜力，但提醒一句，入场需谨慎，设好止损位，别被震下马！这波行情，或可搏一搏，但盈亏自负，切记切记！\n", + "timestamp": "2025-08-10T15:13:34.203982" + }, + { + "message": "现在市场波动很大，你怎么看？", + "response": "市场波动大？正合我意！乱世出英雄，震荡出机会！这正是剑仙我辈大展身手之时！技术分析看穿迷雾，短线操作把握良机。但切记，风浪越大越要稳住船舵，设好止损，见好就收，莫贪恋！\n", + "timestamp": "2025-08-10T15:13:35.458763" + }, + { + "message": "你之前不是看好特斯拉吗？现在还是这个观点吗？", + "response": "这位股友，宝剑锋从磨砺出，梅花香自苦寒来！特斯拉虽遇风浪，但我仍看好它的长远潜力。短期震荡乃兵家常事，我会密切关注技术指标，伺机而动。剑仙的眼光，可不是轻易改变的！当然，投资需谨慎，切莫盲从，一切盈亏还需自负！\n", + "timestamp": "2025-08-10T15:13:37.048007" + } + ], + "何仙姑": [ + { + "message": "特斯拉股票风险大吗？", + "response": "这位朋友，特斯拉股票确实存在一定风险。电动车市场竞争激烈，技术迭代迅速，政策变化也可能带来影响。此外，马斯克个人的言行也可能对股价造成波动。投资需谨慎，建议您充分了解特斯拉的财务状况、行业地位和未来发展规划，结合自身的风险承受能力，审慎决策。\n", + "timestamp": "2025-08-10T15:13:38.280431" + }, + { + "message": "现在适合投资吗？", + "response": "这位朋友，现在市场波动较大，投资环境存在不确定性。虽然特斯拉前景广阔，但也面临竞争压力和技术风险。我建议您谨慎评估，充分了解市场动态和特斯拉的最新情况，并结合自身的风险承受能力，再做决定。稳健投资，安全第一。\n", + "timestamp": "2025-08-10T15:13:39.502875" + }, + { + "message": "你一直很谨慎，现在还是建议观望吗？", + "response": "这位朋友，谨慎是我的本分。当前市场环境依然复杂，特斯拉也面临着诸多挑战。虽然长期来看，其发展潜力巨大，但短期内仍可能存在波动。我仍然建议您保持观望，密切关注市场动态和特斯拉的最新消息，待风险进一步明确后再做决策。安全第一，稳健投资才是长久之计。\n", + "timestamp": "2025-08-10T15:13:40.890509" + } + ] +} \ No newline at end of file diff --git a/package-lock.json b/package-lock.json new file mode 100644 index 0000000..c0aa296 --- /dev/null +++ b/package-lock.json @@ -0,0 +1,1879 @@ +{ + "name": "hyperdrive-neondb-test", + "version": "1.0.0", + "lockfileVersion": 3, + "requires": true, + "packages": { + "": { + "name": "hyperdrive-neondb-test", + "version": "1.0.0", + "license": "MIT", + "dependencies": { + "node-fetch": "^3.3.2", + "pg": "^8.11.3" + }, + "devDependencies": { + "@cloudflare/workers-types": "^4.20240129.0", + "@types/node": "^20.11.16", + "@types/pg": "^8.10.9", + "typescript": "^5.3.3", + "wrangler": "^3.28.2" + } + }, + "node_modules/@cloudflare/kv-asset-handler": { + "version": "0.3.4", + "resolved": "https://registry.npmmirror.com/@cloudflare/kv-asset-handler/-/kv-asset-handler-0.3.4.tgz", + "integrity": "sha512-YLPHc8yASwjNkmcDMQMY35yiWjoKAKnhUbPRszBRS0YgH+IXtsMp61j+yTcnCE3oO2DgP0U3iejLC8FTtKDC8Q==", + "dev": true, + "license": "MIT OR Apache-2.0", + "dependencies": { + "mime": "^3.0.0" + }, + "engines": { + "node": ">=16.13" + } + }, + "node_modules/@cloudflare/unenv-preset": { + "version": "2.0.2", + "resolved": "https://registry.npmmirror.com/@cloudflare/unenv-preset/-/unenv-preset-2.0.2.tgz", + "integrity": "sha512-nyzYnlZjjV5xT3LizahG1Iu6mnrCaxglJ04rZLpDwlDVDZ7v46lNsfxhV3A/xtfgQuSHmLnc6SVI+KwBpc3Lwg==", + "dev": true, + "license": "MIT OR Apache-2.0", + "peerDependencies": { + "unenv": "2.0.0-rc.14", + "workerd": "^1.20250124.0" + }, + "peerDependenciesMeta": { + "workerd": { + "optional": true + } + } + }, + "node_modules/@cloudflare/workerd-darwin-64": { + "version": "1.20250718.0", + "resolved": "https://registry.npmmirror.com/@cloudflare/workerd-darwin-64/-/workerd-darwin-64-1.20250718.0.tgz", + "integrity": "sha512-FHf4t7zbVN8yyXgQ/r/GqLPaYZSGUVzeR7RnL28Mwj2djyw2ZergvytVc7fdGcczl6PQh+VKGfZCfUqpJlbi9g==", + "cpu": [ + "x64" + ], + "dev": true, + "license": "Apache-2.0", + "optional": true, + "os": [ + "darwin" + ], + "engines": { + "node": ">=16" + } + }, + "node_modules/@cloudflare/workerd-darwin-arm64": { + "version": "1.20250718.0", + "resolved": "https://registry.npmmirror.com/@cloudflare/workerd-darwin-arm64/-/workerd-darwin-arm64-1.20250718.0.tgz", + "integrity": "sha512-fUiyUJYyqqp4NqJ0YgGtp4WJh/II/YZsUnEb6vVy5Oeas8lUOxnN+ZOJ8N/6/5LQCVAtYCChRiIrBbfhTn5Z8Q==", + "cpu": [ + "arm64" + ], + "dev": true, + "license": "Apache-2.0", + "optional": true, + "os": [ + "darwin" + ], + "engines": { + "node": ">=16" + } + }, + "node_modules/@cloudflare/workerd-linux-64": { + "version": "1.20250718.0", + "resolved": "https://registry.npmmirror.com/@cloudflare/workerd-linux-64/-/workerd-linux-64-1.20250718.0.tgz", + "integrity": "sha512-5+eb3rtJMiEwp08Kryqzzu8d1rUcK+gdE442auo5eniMpT170Dz0QxBrqkg2Z48SFUPYbj+6uknuA5tzdRSUSg==", + "cpu": [ + "x64" + ], + "dev": true, + "license": "Apache-2.0", + "optional": true, + "os": [ + "linux" + ], + "engines": { + "node": ">=16" + } + }, + "node_modules/@cloudflare/workerd-linux-arm64": { + "version": "1.20250718.0", + "resolved": "https://registry.npmmirror.com/@cloudflare/workerd-linux-arm64/-/workerd-linux-arm64-1.20250718.0.tgz", + "integrity": "sha512-Aa2M/DVBEBQDdATMbn217zCSFKE+ud/teS+fFS+OQqKABLn0azO2qq6ANAHYOIE6Q3Sq4CxDIQr8lGdaJHwUog==", + "cpu": [ + "arm64" + ], + "dev": true, + "license": "Apache-2.0", + "optional": true, + "os": [ + "linux" + ], + "engines": { + "node": ">=16" + } + }, + "node_modules/@cloudflare/workerd-windows-64": { + "version": "1.20250718.0", + "resolved": "https://registry.npmmirror.com/@cloudflare/workerd-windows-64/-/workerd-windows-64-1.20250718.0.tgz", + "integrity": "sha512-dY16RXKffmugnc67LTbyjdDHZn5NoTF1yHEf2fN4+OaOnoGSp3N1x77QubTDwqZ9zECWxgQfDLjddcH8dWeFhg==", + "cpu": [ + "x64" + ], + "dev": true, + "license": "Apache-2.0", + "optional": true, + "os": [ + "win32" + ], + "engines": { + "node": ">=16" + } + }, + "node_modules/@cloudflare/workers-types": { + "version": "4.20250813.0", + "resolved": "https://registry.npmmirror.com/@cloudflare/workers-types/-/workers-types-4.20250813.0.tgz", + "integrity": "sha512-RFFjomDndGR+p7ug1HWDlW21qOJyRZbmI99dUtuR9tmwJbSZhUUnSFmzok9lBYVfkMMrO1O5vmB+IlgiecgLEA==", + "dev": true, + "license": "MIT OR Apache-2.0" + }, + "node_modules/@cspotcode/source-map-support": { + "version": "0.8.1", + "resolved": "https://registry.npmmirror.com/@cspotcode/source-map-support/-/source-map-support-0.8.1.tgz", + "integrity": "sha512-IchNf6dN4tHoMFIn/7OE8LWZ19Y6q/67Bmf6vnGREv8RSbBVb9LPJxEcnwrcwX6ixSvaiGoomAUvu4YSxXrVgw==", + "dev": true, + "license": "MIT", + "dependencies": { + "@jridgewell/trace-mapping": "0.3.9" + }, + "engines": { + "node": ">=12" + } + }, + "node_modules/@emnapi/runtime": { + "version": "1.4.5", + "resolved": "https://registry.npmmirror.com/@emnapi/runtime/-/runtime-1.4.5.tgz", + "integrity": "sha512-++LApOtY0pEEz1zrd9vy1/zXVaVJJ/EbAF3u0fXIzPJEDtnITsBGbbK0EkM72amhl/R5b+5xx0Y/QhcVOpuulg==", + "dev": true, + "license": "MIT", + "optional": true, + "dependencies": { + "tslib": "^2.4.0" + } + }, + "node_modules/@esbuild-plugins/node-globals-polyfill": { + "version": "0.2.3", + "resolved": "https://registry.npmmirror.com/@esbuild-plugins/node-globals-polyfill/-/node-globals-polyfill-0.2.3.tgz", + "integrity": "sha512-r3MIryXDeXDOZh7ih1l/yE9ZLORCd5e8vWg02azWRGj5SPTuoh69A2AIyn0Z31V/kHBfZ4HgWJ+OK3GTTwLmnw==", + "dev": true, + "license": "ISC", + "peerDependencies": { + "esbuild": "*" + } + }, + "node_modules/@esbuild-plugins/node-modules-polyfill": { + "version": "0.2.2", + "resolved": "https://registry.npmmirror.com/@esbuild-plugins/node-modules-polyfill/-/node-modules-polyfill-0.2.2.tgz", + "integrity": "sha512-LXV7QsWJxRuMYvKbiznh+U1ilIop3g2TeKRzUxOG5X3YITc8JyyTa90BmLwqqv0YnX4v32CSlG+vsziZp9dMvA==", + "dev": true, + "license": "ISC", + "dependencies": { + "escape-string-regexp": "^4.0.0", + "rollup-plugin-node-polyfills": "^0.2.1" + }, + "peerDependencies": { + "esbuild": "*" + } + }, + "node_modules/@esbuild/android-arm": { + "version": "0.17.19", + "resolved": "https://registry.npmmirror.com/@esbuild/android-arm/-/android-arm-0.17.19.tgz", + "integrity": "sha512-rIKddzqhmav7MSmoFCmDIb6e2W57geRsM94gV2l38fzhXMwq7hZoClug9USI2pFRGL06f4IOPHHpFNOkWieR8A==", + "cpu": [ + "arm" + ], + "dev": true, + "license": "MIT", + "optional": true, + "os": [ + "android" + ], + "engines": { + "node": ">=12" + } + }, + "node_modules/@esbuild/android-arm64": { + "version": "0.17.19", + "resolved": "https://registry.npmmirror.com/@esbuild/android-arm64/-/android-arm64-0.17.19.tgz", + "integrity": "sha512-KBMWvEZooR7+kzY0BtbTQn0OAYY7CsiydT63pVEaPtVYF0hXbUaOyZog37DKxK7NF3XacBJOpYT4adIJh+avxA==", + "cpu": [ + "arm64" + ], + "dev": true, + "license": "MIT", + "optional": true, + "os": [ + "android" + ], + "engines": { + "node": ">=12" + } + }, + "node_modules/@esbuild/android-x64": { + "version": "0.17.19", + "resolved": "https://registry.npmmirror.com/@esbuild/android-x64/-/android-x64-0.17.19.tgz", + "integrity": "sha512-uUTTc4xGNDT7YSArp/zbtmbhO0uEEK9/ETW29Wk1thYUJBz3IVnvgEiEwEa9IeLyvnpKrWK64Utw2bgUmDveww==", + "cpu": [ + "x64" + ], + "dev": true, + "license": "MIT", + "optional": true, + "os": [ + "android" + ], + "engines": { + "node": ">=12" + } + }, + "node_modules/@esbuild/darwin-arm64": { + "version": "0.17.19", + "resolved": "https://registry.npmmirror.com/@esbuild/darwin-arm64/-/darwin-arm64-0.17.19.tgz", + "integrity": "sha512-80wEoCfF/hFKM6WE1FyBHc9SfUblloAWx6FJkFWTWiCoht9Mc0ARGEM47e67W9rI09YoUxJL68WHfDRYEAvOhg==", + "cpu": [ + "arm64" + ], + "dev": true, + "license": "MIT", + "optional": true, + "os": [ + "darwin" + ], + "engines": { + "node": ">=12" + } + }, + "node_modules/@esbuild/darwin-x64": { + "version": "0.17.19", + "resolved": "https://registry.npmmirror.com/@esbuild/darwin-x64/-/darwin-x64-0.17.19.tgz", + "integrity": "sha512-IJM4JJsLhRYr9xdtLytPLSH9k/oxR3boaUIYiHkAawtwNOXKE8KoU8tMvryogdcT8AU+Bflmh81Xn6Q0vTZbQw==", + "cpu": [ + "x64" + ], + "dev": true, + "license": "MIT", + "optional": true, + "os": [ + "darwin" + ], + "engines": { + "node": ">=12" + } + }, + "node_modules/@esbuild/freebsd-arm64": { + "version": "0.17.19", + "resolved": "https://registry.npmmirror.com/@esbuild/freebsd-arm64/-/freebsd-arm64-0.17.19.tgz", + "integrity": "sha512-pBwbc7DufluUeGdjSU5Si+P3SoMF5DQ/F/UmTSb8HXO80ZEAJmrykPyzo1IfNbAoaqw48YRpv8shwd1NoI0jcQ==", + "cpu": [ + "arm64" + ], + "dev": true, + "license": "MIT", + "optional": true, + "os": [ + "freebsd" + ], + "engines": { + "node": ">=12" + } + }, + "node_modules/@esbuild/freebsd-x64": { + "version": "0.17.19", + "resolved": "https://registry.npmmirror.com/@esbuild/freebsd-x64/-/freebsd-x64-0.17.19.tgz", + "integrity": "sha512-4lu+n8Wk0XlajEhbEffdy2xy53dpR06SlzvhGByyg36qJw6Kpfk7cp45DR/62aPH9mtJRmIyrXAS5UWBrJT6TQ==", + "cpu": [ + "x64" + ], + "dev": true, + "license": "MIT", + "optional": true, + "os": [ + "freebsd" + ], + "engines": { + "node": ">=12" + } + }, + "node_modules/@esbuild/linux-arm": { + "version": "0.17.19", + "resolved": "https://registry.npmmirror.com/@esbuild/linux-arm/-/linux-arm-0.17.19.tgz", + "integrity": "sha512-cdmT3KxjlOQ/gZ2cjfrQOtmhG4HJs6hhvm3mWSRDPtZ/lP5oe8FWceS10JaSJC13GBd4eH/haHnqf7hhGNLerA==", + "cpu": [ + "arm" + ], + "dev": true, + "license": "MIT", + "optional": true, + "os": [ + "linux" + ], + "engines": { + "node": ">=12" + } + }, + "node_modules/@esbuild/linux-arm64": { + "version": "0.17.19", + "resolved": "https://registry.npmmirror.com/@esbuild/linux-arm64/-/linux-arm64-0.17.19.tgz", + "integrity": "sha512-ct1Tg3WGwd3P+oZYqic+YZF4snNl2bsnMKRkb3ozHmnM0dGWuxcPTTntAF6bOP0Sp4x0PjSF+4uHQ1xvxfRKqg==", + "cpu": [ + "arm64" + ], + "dev": true, + "license": "MIT", + "optional": true, + "os": [ + "linux" + ], + "engines": { + "node": ">=12" + } + }, + "node_modules/@esbuild/linux-ia32": { + "version": "0.17.19", + "resolved": "https://registry.npmmirror.com/@esbuild/linux-ia32/-/linux-ia32-0.17.19.tgz", + "integrity": "sha512-w4IRhSy1VbsNxHRQpeGCHEmibqdTUx61Vc38APcsRbuVgK0OPEnQ0YD39Brymn96mOx48Y2laBQGqgZ0j9w6SQ==", + "cpu": [ + "ia32" + ], + "dev": true, + "license": "MIT", + "optional": true, + "os": [ + "linux" + ], + "engines": { + "node": ">=12" + } + }, + "node_modules/@esbuild/linux-loong64": { + "version": "0.17.19", + "resolved": "https://registry.npmmirror.com/@esbuild/linux-loong64/-/linux-loong64-0.17.19.tgz", + "integrity": "sha512-2iAngUbBPMq439a+z//gE+9WBldoMp1s5GWsUSgqHLzLJ9WoZLZhpwWuym0u0u/4XmZ3gpHmzV84PonE+9IIdQ==", + "cpu": [ + "loong64" + ], + "dev": true, + "license": "MIT", + "optional": true, + "os": [ + "linux" + ], + "engines": { + "node": ">=12" + } + }, + "node_modules/@esbuild/linux-mips64el": { + "version": "0.17.19", + "resolved": "https://registry.npmmirror.com/@esbuild/linux-mips64el/-/linux-mips64el-0.17.19.tgz", + "integrity": "sha512-LKJltc4LVdMKHsrFe4MGNPp0hqDFA1Wpt3jE1gEyM3nKUvOiO//9PheZZHfYRfYl6AwdTH4aTcXSqBerX0ml4A==", + "cpu": [ + "mips64el" + ], + "dev": true, + "license": "MIT", + "optional": true, + "os": [ + "linux" + ], + "engines": { + "node": ">=12" + } + }, + "node_modules/@esbuild/linux-ppc64": { + "version": "0.17.19", + "resolved": "https://registry.npmmirror.com/@esbuild/linux-ppc64/-/linux-ppc64-0.17.19.tgz", + "integrity": "sha512-/c/DGybs95WXNS8y3Ti/ytqETiW7EU44MEKuCAcpPto3YjQbyK3IQVKfF6nbghD7EcLUGl0NbiL5Rt5DMhn5tg==", + "cpu": [ + "ppc64" + ], + "dev": true, + "license": "MIT", + "optional": true, + "os": [ + "linux" + ], + "engines": { + "node": ">=12" + } + }, + "node_modules/@esbuild/linux-riscv64": { + "version": "0.17.19", + "resolved": "https://registry.npmmirror.com/@esbuild/linux-riscv64/-/linux-riscv64-0.17.19.tgz", + "integrity": "sha512-FC3nUAWhvFoutlhAkgHf8f5HwFWUL6bYdvLc/TTuxKlvLi3+pPzdZiFKSWz/PF30TB1K19SuCxDTI5KcqASJqA==", + "cpu": [ + "riscv64" + ], + "dev": true, + "license": "MIT", + "optional": true, + "os": [ + "linux" + ], + "engines": { + "node": ">=12" + } + }, + "node_modules/@esbuild/linux-s390x": { + "version": "0.17.19", + "resolved": "https://registry.npmmirror.com/@esbuild/linux-s390x/-/linux-s390x-0.17.19.tgz", + "integrity": "sha512-IbFsFbxMWLuKEbH+7sTkKzL6NJmG2vRyy6K7JJo55w+8xDk7RElYn6xvXtDW8HCfoKBFK69f3pgBJSUSQPr+4Q==", + "cpu": [ + "s390x" + ], + "dev": true, + "license": "MIT", + "optional": true, + "os": [ + "linux" + ], + "engines": { + "node": ">=12" + } + }, + "node_modules/@esbuild/linux-x64": { + "version": "0.17.19", + "resolved": "https://registry.npmmirror.com/@esbuild/linux-x64/-/linux-x64-0.17.19.tgz", + "integrity": "sha512-68ngA9lg2H6zkZcyp22tsVt38mlhWde8l3eJLWkyLrp4HwMUr3c1s/M2t7+kHIhvMjglIBrFpncX1SzMckomGw==", + "cpu": [ + "x64" + ], + "dev": true, + "license": "MIT", + "optional": true, + "os": [ + "linux" + ], + "engines": { + "node": ">=12" + } + }, + "node_modules/@esbuild/netbsd-x64": { + "version": "0.17.19", + "resolved": "https://registry.npmmirror.com/@esbuild/netbsd-x64/-/netbsd-x64-0.17.19.tgz", + "integrity": "sha512-CwFq42rXCR8TYIjIfpXCbRX0rp1jo6cPIUPSaWwzbVI4aOfX96OXY8M6KNmtPcg7QjYeDmN+DD0Wp3LaBOLf4Q==", + "cpu": [ + "x64" + ], + "dev": true, + "license": "MIT", + "optional": true, + "os": [ + "netbsd" + ], + "engines": { + "node": ">=12" + } + }, + "node_modules/@esbuild/openbsd-x64": { + "version": "0.17.19", + "resolved": "https://registry.npmmirror.com/@esbuild/openbsd-x64/-/openbsd-x64-0.17.19.tgz", + "integrity": "sha512-cnq5brJYrSZ2CF6c35eCmviIN3k3RczmHz8eYaVlNasVqsNY+JKohZU5MKmaOI+KkllCdzOKKdPs762VCPC20g==", + "cpu": [ + "x64" + ], + "dev": true, + "license": "MIT", + "optional": true, + "os": [ + "openbsd" + ], + "engines": { + "node": ">=12" + } + }, + "node_modules/@esbuild/sunos-x64": { + "version": "0.17.19", + "resolved": "https://registry.npmmirror.com/@esbuild/sunos-x64/-/sunos-x64-0.17.19.tgz", + "integrity": "sha512-vCRT7yP3zX+bKWFeP/zdS6SqdWB8OIpaRq/mbXQxTGHnIxspRtigpkUcDMlSCOejlHowLqII7K2JKevwyRP2rg==", + "cpu": [ + "x64" + ], + "dev": true, + "license": "MIT", + "optional": true, + "os": [ + "sunos" + ], + "engines": { + "node": ">=12" + } + }, + "node_modules/@esbuild/win32-arm64": { + "version": "0.17.19", + "resolved": "https://registry.npmmirror.com/@esbuild/win32-arm64/-/win32-arm64-0.17.19.tgz", + "integrity": "sha512-yYx+8jwowUstVdorcMdNlzklLYhPxjniHWFKgRqH7IFlUEa0Umu3KuYplf1HUZZ422e3NU9F4LGb+4O0Kdcaag==", + "cpu": [ + "arm64" + ], + "dev": true, + "license": "MIT", + "optional": true, + "os": [ + "win32" + ], + "engines": { + "node": ">=12" + } + }, + "node_modules/@esbuild/win32-ia32": { + "version": "0.17.19", + "resolved": "https://registry.npmmirror.com/@esbuild/win32-ia32/-/win32-ia32-0.17.19.tgz", + "integrity": "sha512-eggDKanJszUtCdlVs0RB+h35wNlb5v4TWEkq4vZcmVt5u/HiDZrTXe2bWFQUez3RgNHwx/x4sk5++4NSSicKkw==", + "cpu": [ + "ia32" + ], + "dev": true, + "license": "MIT", + "optional": true, + "os": [ + "win32" + ], + "engines": { + "node": ">=12" + } + }, + "node_modules/@esbuild/win32-x64": { + "version": "0.17.19", + "resolved": "https://registry.npmmirror.com/@esbuild/win32-x64/-/win32-x64-0.17.19.tgz", + "integrity": "sha512-lAhycmKnVOuRYNtRtatQR1LPQf2oYCkRGkSFnseDAKPl8lu5SOsK/e1sXe5a0Pc5kHIHe6P2I/ilntNv2xf3cA==", + "cpu": [ + "x64" + ], + "dev": true, + "license": "MIT", + "optional": true, + "os": [ + "win32" + ], + "engines": { + "node": ">=12" + } + }, + "node_modules/@fastify/busboy": { + "version": "2.1.1", + "resolved": "https://registry.npmmirror.com/@fastify/busboy/-/busboy-2.1.1.tgz", + "integrity": "sha512-vBZP4NlzfOlerQTnba4aqZoMhE/a9HY7HRqoOPaETQcSQuWEIyZMHGfVu6w9wGtGK5fED5qRs2DteVCjOH60sA==", + "dev": true, + "license": "MIT", + "engines": { + "node": ">=14" + } + }, + "node_modules/@img/sharp-darwin-arm64": { + "version": "0.33.5", + "resolved": "https://registry.npmmirror.com/@img/sharp-darwin-arm64/-/sharp-darwin-arm64-0.33.5.tgz", + "integrity": "sha512-UT4p+iz/2H4twwAoLCqfA9UH5pI6DggwKEGuaPy7nCVQ8ZsiY5PIcrRvD1DzuY3qYL07NtIQcWnBSY/heikIFQ==", + "cpu": [ + "arm64" + ], + "dev": true, + "license": "Apache-2.0", + "optional": true, + "os": [ + "darwin" + ], + "engines": { + "node": "^18.17.0 || ^20.3.0 || >=21.0.0" + }, + "funding": { + "url": "https://opencollective.com/libvips" + }, + "optionalDependencies": { + "@img/sharp-libvips-darwin-arm64": "1.0.4" + } + }, + "node_modules/@img/sharp-darwin-x64": { + "version": "0.33.5", + "resolved": "https://registry.npmmirror.com/@img/sharp-darwin-x64/-/sharp-darwin-x64-0.33.5.tgz", + "integrity": "sha512-fyHac4jIc1ANYGRDxtiqelIbdWkIuQaI84Mv45KvGRRxSAa7o7d1ZKAOBaYbnepLC1WqxfpimdeWfvqqSGwR2Q==", + "cpu": [ + "x64" + ], + "dev": true, + "license": "Apache-2.0", + "optional": true, + "os": [ + "darwin" + ], + "engines": { + "node": "^18.17.0 || ^20.3.0 || >=21.0.0" + }, + "funding": { + "url": "https://opencollective.com/libvips" + }, + "optionalDependencies": { + "@img/sharp-libvips-darwin-x64": "1.0.4" + } + }, + "node_modules/@img/sharp-libvips-darwin-arm64": { + "version": "1.0.4", + "resolved": "https://registry.npmmirror.com/@img/sharp-libvips-darwin-arm64/-/sharp-libvips-darwin-arm64-1.0.4.tgz", + "integrity": "sha512-XblONe153h0O2zuFfTAbQYAX2JhYmDHeWikp1LM9Hul9gVPjFY427k6dFEcOL72O01QxQsWi761svJ/ev9xEDg==", + "cpu": [ + "arm64" + ], + "dev": true, + "license": "LGPL-3.0-or-later", + "optional": true, + "os": [ + "darwin" + ], + "funding": { + "url": "https://opencollective.com/libvips" + } + }, + "node_modules/@img/sharp-libvips-darwin-x64": { + "version": "1.0.4", + "resolved": "https://registry.npmmirror.com/@img/sharp-libvips-darwin-x64/-/sharp-libvips-darwin-x64-1.0.4.tgz", + "integrity": "sha512-xnGR8YuZYfJGmWPvmlunFaWJsb9T/AO2ykoP3Fz/0X5XV2aoYBPkX6xqCQvUTKKiLddarLaxpzNe+b1hjeWHAQ==", + "cpu": [ + "x64" + ], + "dev": true, + "license": "LGPL-3.0-or-later", + "optional": true, + "os": [ + "darwin" + ], + "funding": { + "url": "https://opencollective.com/libvips" + } + }, + "node_modules/@img/sharp-libvips-linux-arm": { + "version": "1.0.5", + "resolved": "https://registry.npmmirror.com/@img/sharp-libvips-linux-arm/-/sharp-libvips-linux-arm-1.0.5.tgz", + "integrity": "sha512-gvcC4ACAOPRNATg/ov8/MnbxFDJqf/pDePbBnuBDcjsI8PssmjoKMAz4LtLaVi+OnSb5FK/yIOamqDwGmXW32g==", + "cpu": [ + "arm" + ], + "dev": true, + "license": "LGPL-3.0-or-later", + "optional": true, + "os": [ + "linux" + ], + "funding": { + "url": "https://opencollective.com/libvips" + } + }, + "node_modules/@img/sharp-libvips-linux-arm64": { + "version": "1.0.4", + "resolved": "https://registry.npmmirror.com/@img/sharp-libvips-linux-arm64/-/sharp-libvips-linux-arm64-1.0.4.tgz", + "integrity": "sha512-9B+taZ8DlyyqzZQnoeIvDVR/2F4EbMepXMc/NdVbkzsJbzkUjhXv/70GQJ7tdLA4YJgNP25zukcxpX2/SueNrA==", + "cpu": [ + "arm64" + ], + "dev": true, + "license": "LGPL-3.0-or-later", + "optional": true, + "os": [ + "linux" + ], + "funding": { + "url": "https://opencollective.com/libvips" + } + }, + "node_modules/@img/sharp-libvips-linux-s390x": { + "version": "1.0.4", + "resolved": "https://registry.npmmirror.com/@img/sharp-libvips-linux-s390x/-/sharp-libvips-linux-s390x-1.0.4.tgz", + "integrity": "sha512-u7Wz6ntiSSgGSGcjZ55im6uvTrOxSIS8/dgoVMoiGE9I6JAfU50yH5BoDlYA1tcuGS7g/QNtetJnxA6QEsCVTA==", + "cpu": [ + "s390x" + ], + "dev": true, + "license": "LGPL-3.0-or-later", + "optional": true, + "os": [ + "linux" + ], + "funding": { + "url": "https://opencollective.com/libvips" + } + }, + "node_modules/@img/sharp-libvips-linux-x64": { + "version": "1.0.4", + "resolved": "https://registry.npmmirror.com/@img/sharp-libvips-linux-x64/-/sharp-libvips-linux-x64-1.0.4.tgz", + "integrity": "sha512-MmWmQ3iPFZr0Iev+BAgVMb3ZyC4KeFc3jFxnNbEPas60e1cIfevbtuyf9nDGIzOaW9PdnDciJm+wFFaTlj5xYw==", + "cpu": [ + "x64" + ], + "dev": true, + "license": "LGPL-3.0-or-later", + "optional": true, + "os": [ + "linux" + ], + "funding": { + "url": "https://opencollective.com/libvips" + } + }, + "node_modules/@img/sharp-libvips-linuxmusl-arm64": { + "version": "1.0.4", + "resolved": "https://registry.npmmirror.com/@img/sharp-libvips-linuxmusl-arm64/-/sharp-libvips-linuxmusl-arm64-1.0.4.tgz", + "integrity": "sha512-9Ti+BbTYDcsbp4wfYib8Ctm1ilkugkA/uscUn6UXK1ldpC1JjiXbLfFZtRlBhjPZ5o1NCLiDbg8fhUPKStHoTA==", + "cpu": [ + "arm64" + ], + "dev": true, + "license": "LGPL-3.0-or-later", + "optional": true, + "os": [ + "linux" + ], + "funding": { + "url": "https://opencollective.com/libvips" + } + }, + "node_modules/@img/sharp-libvips-linuxmusl-x64": { + "version": "1.0.4", + "resolved": "https://registry.npmmirror.com/@img/sharp-libvips-linuxmusl-x64/-/sharp-libvips-linuxmusl-x64-1.0.4.tgz", + "integrity": "sha512-viYN1KX9m+/hGkJtvYYp+CCLgnJXwiQB39damAO7WMdKWlIhmYTfHjwSbQeUK/20vY154mwezd9HflVFM1wVSw==", + "cpu": [ + "x64" + ], + "dev": true, + "license": "LGPL-3.0-or-later", + "optional": true, + "os": [ + "linux" + ], + "funding": { + "url": "https://opencollective.com/libvips" + } + }, + "node_modules/@img/sharp-linux-arm": { + "version": "0.33.5", + "resolved": "https://registry.npmmirror.com/@img/sharp-linux-arm/-/sharp-linux-arm-0.33.5.tgz", + "integrity": "sha512-JTS1eldqZbJxjvKaAkxhZmBqPRGmxgu+qFKSInv8moZ2AmT5Yib3EQ1c6gp493HvrvV8QgdOXdyaIBrhvFhBMQ==", + "cpu": [ + "arm" + ], + "dev": true, + "license": "Apache-2.0", + "optional": true, + "os": [ + "linux" + ], + "engines": { + "node": "^18.17.0 || ^20.3.0 || >=21.0.0" + }, + "funding": { + "url": "https://opencollective.com/libvips" + }, + "optionalDependencies": { + "@img/sharp-libvips-linux-arm": "1.0.5" + } + }, + "node_modules/@img/sharp-linux-arm64": { + "version": "0.33.5", + "resolved": "https://registry.npmmirror.com/@img/sharp-linux-arm64/-/sharp-linux-arm64-0.33.5.tgz", + "integrity": "sha512-JMVv+AMRyGOHtO1RFBiJy/MBsgz0x4AWrT6QoEVVTyh1E39TrCUpTRI7mx9VksGX4awWASxqCYLCV4wBZHAYxA==", + "cpu": [ + "arm64" + ], + "dev": true, + "license": "Apache-2.0", + "optional": true, + "os": [ + "linux" + ], + "engines": { + "node": "^18.17.0 || ^20.3.0 || >=21.0.0" + }, + "funding": { + "url": "https://opencollective.com/libvips" + }, + "optionalDependencies": { + "@img/sharp-libvips-linux-arm64": "1.0.4" + } + }, + "node_modules/@img/sharp-linux-s390x": { + "version": "0.33.5", + "resolved": "https://registry.npmmirror.com/@img/sharp-linux-s390x/-/sharp-linux-s390x-0.33.5.tgz", + "integrity": "sha512-y/5PCd+mP4CA/sPDKl2961b+C9d+vPAveS33s6Z3zfASk2j5upL6fXVPZi7ztePZ5CuH+1kW8JtvxgbuXHRa4Q==", + "cpu": [ + "s390x" + ], + "dev": true, + "license": "Apache-2.0", + "optional": true, + "os": [ + "linux" + ], + "engines": { + "node": "^18.17.0 || ^20.3.0 || >=21.0.0" + }, + "funding": { + "url": "https://opencollective.com/libvips" + }, + "optionalDependencies": { + "@img/sharp-libvips-linux-s390x": "1.0.4" + } + }, + "node_modules/@img/sharp-linux-x64": { + "version": "0.33.5", + "resolved": "https://registry.npmmirror.com/@img/sharp-linux-x64/-/sharp-linux-x64-0.33.5.tgz", + "integrity": "sha512-opC+Ok5pRNAzuvq1AG0ar+1owsu842/Ab+4qvU879ippJBHvyY5n2mxF1izXqkPYlGuP/M556uh53jRLJmzTWA==", + "cpu": [ + "x64" + ], + "dev": true, + "license": "Apache-2.0", + "optional": true, + "os": [ + "linux" + ], + "engines": { + "node": "^18.17.0 || ^20.3.0 || >=21.0.0" + }, + "funding": { + "url": "https://opencollective.com/libvips" + }, + "optionalDependencies": { + "@img/sharp-libvips-linux-x64": "1.0.4" + } + }, + "node_modules/@img/sharp-linuxmusl-arm64": { + "version": "0.33.5", + "resolved": "https://registry.npmmirror.com/@img/sharp-linuxmusl-arm64/-/sharp-linuxmusl-arm64-0.33.5.tgz", + "integrity": "sha512-XrHMZwGQGvJg2V/oRSUfSAfjfPxO+4DkiRh6p2AFjLQztWUuY/o8Mq0eMQVIY7HJ1CDQUJlxGGZRw1a5bqmd1g==", + "cpu": [ + "arm64" + ], + "dev": true, + "license": "Apache-2.0", + "optional": true, + "os": [ + "linux" + ], + "engines": { + "node": "^18.17.0 || ^20.3.0 || >=21.0.0" + }, + "funding": { + "url": "https://opencollective.com/libvips" + }, + "optionalDependencies": { + "@img/sharp-libvips-linuxmusl-arm64": "1.0.4" + } + }, + "node_modules/@img/sharp-linuxmusl-x64": { + "version": "0.33.5", + "resolved": "https://registry.npmmirror.com/@img/sharp-linuxmusl-x64/-/sharp-linuxmusl-x64-0.33.5.tgz", + "integrity": "sha512-WT+d/cgqKkkKySYmqoZ8y3pxx7lx9vVejxW/W4DOFMYVSkErR+w7mf2u8m/y4+xHe7yY9DAXQMWQhpnMuFfScw==", + "cpu": [ + "x64" + ], + "dev": true, + "license": "Apache-2.0", + "optional": true, + "os": [ + "linux" + ], + "engines": { + "node": "^18.17.0 || ^20.3.0 || >=21.0.0" + }, + "funding": { + "url": "https://opencollective.com/libvips" + }, + "optionalDependencies": { + "@img/sharp-libvips-linuxmusl-x64": "1.0.4" + } + }, + "node_modules/@img/sharp-wasm32": { + "version": "0.33.5", + "resolved": "https://registry.npmmirror.com/@img/sharp-wasm32/-/sharp-wasm32-0.33.5.tgz", + "integrity": "sha512-ykUW4LVGaMcU9lu9thv85CbRMAwfeadCJHRsg2GmeRa/cJxsVY9Rbd57JcMxBkKHag5U/x7TSBpScF4U8ElVzg==", + "cpu": [ + "wasm32" + ], + "dev": true, + "license": "Apache-2.0 AND LGPL-3.0-or-later AND MIT", + "optional": true, + "dependencies": { + "@emnapi/runtime": "^1.2.0" + }, + "engines": { + "node": "^18.17.0 || ^20.3.0 || >=21.0.0" + }, + "funding": { + "url": "https://opencollective.com/libvips" + } + }, + "node_modules/@img/sharp-win32-ia32": { + "version": "0.33.5", + "resolved": "https://registry.npmmirror.com/@img/sharp-win32-ia32/-/sharp-win32-ia32-0.33.5.tgz", + "integrity": "sha512-T36PblLaTwuVJ/zw/LaH0PdZkRz5rd3SmMHX8GSmR7vtNSP5Z6bQkExdSK7xGWyxLw4sUknBuugTelgw2faBbQ==", + "cpu": [ + "ia32" + ], + "dev": true, + "license": "Apache-2.0 AND LGPL-3.0-or-later", + "optional": true, + "os": [ + "win32" + ], + "engines": { + "node": "^18.17.0 || ^20.3.0 || >=21.0.0" + }, + "funding": { + "url": "https://opencollective.com/libvips" + } + }, + "node_modules/@img/sharp-win32-x64": { + "version": "0.33.5", + "resolved": "https://registry.npmmirror.com/@img/sharp-win32-x64/-/sharp-win32-x64-0.33.5.tgz", + "integrity": "sha512-MpY/o8/8kj+EcnxwvrP4aTJSWw/aZ7JIGR4aBeZkZw5B7/Jn+tY9/VNwtcoGmdT7GfggGIU4kygOMSbYnOrAbg==", + "cpu": [ + "x64" + ], + "dev": true, + "license": "Apache-2.0 AND LGPL-3.0-or-later", + "optional": true, + "os": [ + "win32" + ], + "engines": { + "node": "^18.17.0 || ^20.3.0 || >=21.0.0" + }, + "funding": { + "url": "https://opencollective.com/libvips" + } + }, + "node_modules/@jridgewell/resolve-uri": { + "version": "3.1.2", + "resolved": "https://registry.npmmirror.com/@jridgewell/resolve-uri/-/resolve-uri-3.1.2.tgz", + "integrity": "sha512-bRISgCIjP20/tbWSPWMEi54QVPRZExkuD9lJL+UIxUKtwVJA8wW1Trb1jMs1RFXo1CBTNZ/5hpC9QvmKWdopKw==", + "dev": true, + "license": "MIT", + "engines": { + "node": ">=6.0.0" + } + }, + "node_modules/@jridgewell/sourcemap-codec": { + "version": "1.5.5", + "resolved": "https://registry.npmmirror.com/@jridgewell/sourcemap-codec/-/sourcemap-codec-1.5.5.tgz", + "integrity": "sha512-cYQ9310grqxueWbl+WuIUIaiUaDcj7WOq5fVhEljNVgRfOUhY9fy2zTvfoqWsnebh8Sl70VScFbICvJnLKB0Og==", + "dev": true, + "license": "MIT" + }, + "node_modules/@jridgewell/trace-mapping": { + "version": "0.3.9", + "resolved": "https://registry.npmmirror.com/@jridgewell/trace-mapping/-/trace-mapping-0.3.9.tgz", + "integrity": "sha512-3Belt6tdc8bPgAtbcmdtNJlirVoTmEb5e2gC94PnkwEW9jI6CAHUeoG85tjWP5WquqfavoMtMwiG4P926ZKKuQ==", + "dev": true, + "license": "MIT", + "dependencies": { + "@jridgewell/resolve-uri": "^3.0.3", + "@jridgewell/sourcemap-codec": "^1.4.10" + } + }, + "node_modules/@types/node": { + "version": "20.19.10", + "resolved": "https://registry.npmmirror.com/@types/node/-/node-20.19.10.tgz", + "integrity": "sha512-iAFpG6DokED3roLSP0K+ybeDdIX6Bc0Vd3mLW5uDqThPWtNos3E+EqOM11mPQHKzfWHqEBuLjIlsBQQ8CsISmQ==", + "dev": true, + "license": "MIT", + "dependencies": { + "undici-types": "~6.21.0" + } + }, + "node_modules/@types/pg": { + "version": "8.15.5", + "resolved": "https://registry.npmmirror.com/@types/pg/-/pg-8.15.5.tgz", + "integrity": "sha512-LF7lF6zWEKxuT3/OR8wAZGzkg4ENGXFNyiV/JeOt9z5B+0ZVwbql9McqX5c/WStFq1GaGso7H1AzP/qSzmlCKQ==", + "dev": true, + "license": "MIT", + "dependencies": { + "@types/node": "*", + "pg-protocol": "*", + "pg-types": "^2.2.0" + } + }, + "node_modules/acorn": { + "version": "8.14.0", + "resolved": "https://registry.npmmirror.com/acorn/-/acorn-8.14.0.tgz", + "integrity": "sha512-cl669nCJTZBsL97OF4kUQm5g5hC2uihk0NxY3WENAC0TYdILVkAyHymAntgxGkl7K+t0cXIrH5siy5S4XkFycA==", + "dev": true, + "license": "MIT", + "bin": { + "acorn": "bin/acorn" + }, + "engines": { + "node": ">=0.4.0" + } + }, + "node_modules/acorn-walk": { + "version": "8.3.2", + "resolved": "https://registry.npmmirror.com/acorn-walk/-/acorn-walk-8.3.2.tgz", + "integrity": "sha512-cjkyv4OtNCIeqhHrfS81QWXoCBPExR/J62oyEqepVw8WaQeSqpW2uhuLPh1m9eWhDuOo/jUXVTlifvesOWp/4A==", + "dev": true, + "license": "MIT", + "engines": { + "node": ">=0.4.0" + } + }, + "node_modules/as-table": { + "version": "1.0.55", + "resolved": "https://registry.npmmirror.com/as-table/-/as-table-1.0.55.tgz", + "integrity": "sha512-xvsWESUJn0JN421Xb9MQw6AsMHRCUknCe0Wjlxvjud80mU4E6hQf1A6NzQKcYNmYw62MfzEtXc+badstZP3JpQ==", + "dev": true, + "license": "MIT", + "dependencies": { + "printable-characters": "^1.0.42" + } + }, + "node_modules/blake3-wasm": { + "version": "2.1.5", + "resolved": "https://registry.npmmirror.com/blake3-wasm/-/blake3-wasm-2.1.5.tgz", + "integrity": "sha512-F1+K8EbfOZE49dtoPtmxUQrpXaBIl3ICvasLh+nJta0xkz+9kF/7uet9fLnwKqhDrmj6g+6K3Tw9yQPUg2ka5g==", + "dev": true, + "license": "MIT" + }, + "node_modules/color": { + "version": "4.2.3", + "resolved": "https://registry.npmmirror.com/color/-/color-4.2.3.tgz", + "integrity": "sha512-1rXeuUUiGGrykh+CeBdu5Ie7OJwinCgQY0bc7GCRxy5xVHy+moaqkpL/jqQq0MtQOeYcrqEz4abc5f0KtU7W4A==", + "dev": true, + "license": "MIT", + "optional": true, + "dependencies": { + "color-convert": "^2.0.1", + "color-string": "^1.9.0" + }, + "engines": { + "node": ">=12.5.0" + } + }, + "node_modules/color-convert": { + "version": "2.0.1", + "resolved": "https://registry.npmmirror.com/color-convert/-/color-convert-2.0.1.tgz", + "integrity": "sha512-RRECPsj7iu/xb5oKYcsFHSppFNnsj/52OVTRKb4zP5onXwVF3zVmmToNcOfGC+CRDpfK/U584fMg38ZHCaElKQ==", + "dev": true, + "license": "MIT", + "optional": true, + "dependencies": { + "color-name": "~1.1.4" + }, + "engines": { + "node": ">=7.0.0" + } + }, + "node_modules/color-name": { + "version": "1.1.4", + "resolved": "https://registry.npmmirror.com/color-name/-/color-name-1.1.4.tgz", + "integrity": "sha512-dOy+3AuW3a2wNbZHIuMZpTcgjGuLU/uBL/ubcZF9OXbDo8ff4O8yVp5Bf0efS8uEoYo5q4Fx7dY9OgQGXgAsQA==", + "dev": true, + "license": "MIT", + "optional": true + }, + "node_modules/color-string": { + "version": "1.9.1", + "resolved": "https://registry.npmmirror.com/color-string/-/color-string-1.9.1.tgz", + "integrity": "sha512-shrVawQFojnZv6xM40anx4CkoDP+fZsw/ZerEMsW/pyzsRbElpsL/DBVW7q3ExxwusdNXI3lXpuhEZkzs8p5Eg==", + "dev": true, + "license": "MIT", + "optional": true, + "dependencies": { + "color-name": "^1.0.0", + "simple-swizzle": "^0.2.2" + } + }, + "node_modules/cookie": { + "version": "0.7.2", + "resolved": "https://registry.npmmirror.com/cookie/-/cookie-0.7.2.tgz", + "integrity": "sha512-yki5XnKuf750l50uGTllt6kKILY4nQ1eNIQatoXEByZ5dWgnKqbnqmTrBE5B4N7lrMJKQ2ytWMiTO2o0v6Ew/w==", + "dev": true, + "license": "MIT", + "engines": { + "node": ">= 0.6" + } + }, + "node_modules/data-uri-to-buffer": { + "version": "2.0.2", + "resolved": "https://registry.npmmirror.com/data-uri-to-buffer/-/data-uri-to-buffer-2.0.2.tgz", + "integrity": "sha512-ND9qDTLc6diwj+Xe5cdAgVTbLVdXbtxTJRXRhli8Mowuaan+0EJOtdqJ0QCHNSSPyoXGx9HX2/VMnKeC34AChA==", + "dev": true, + "license": "MIT" + }, + "node_modules/defu": { + "version": "6.1.4", + "resolved": "https://registry.npmmirror.com/defu/-/defu-6.1.4.tgz", + "integrity": "sha512-mEQCMmwJu317oSz8CwdIOdwf3xMif1ttiM8LTufzc3g6kR+9Pe236twL8j3IYT1F7GfRgGcW6MWxzZjLIkuHIg==", + "dev": true, + "license": "MIT" + }, + "node_modules/detect-libc": { + "version": "2.0.4", + "resolved": "https://registry.npmmirror.com/detect-libc/-/detect-libc-2.0.4.tgz", + "integrity": "sha512-3UDv+G9CsCKO1WKMGw9fwq/SWJYbI0c5Y7LU1AXYoDdbhE2AHQ6N6Nb34sG8Fj7T5APy8qXDCKuuIHd1BR0tVA==", + "dev": true, + "license": "Apache-2.0", + "optional": true, + "engines": { + "node": ">=8" + } + }, + "node_modules/esbuild": { + "version": "0.17.19", + "resolved": "https://registry.npmmirror.com/esbuild/-/esbuild-0.17.19.tgz", + "integrity": "sha512-XQ0jAPFkK/u3LcVRcvVHQcTIqD6E2H1fvZMA5dQPSOWb3suUbWbfbRf94pjc0bNzRYLfIrDRQXr7X+LHIm5oHw==", + "dev": true, + "hasInstallScript": true, + "license": "MIT", + "bin": { + "esbuild": "bin/esbuild" + }, + "engines": { + "node": ">=12" + }, + "optionalDependencies": { + "@esbuild/android-arm": "0.17.19", + "@esbuild/android-arm64": "0.17.19", + "@esbuild/android-x64": "0.17.19", + "@esbuild/darwin-arm64": "0.17.19", + "@esbuild/darwin-x64": "0.17.19", + "@esbuild/freebsd-arm64": "0.17.19", + "@esbuild/freebsd-x64": "0.17.19", + "@esbuild/linux-arm": "0.17.19", + "@esbuild/linux-arm64": "0.17.19", + "@esbuild/linux-ia32": "0.17.19", + "@esbuild/linux-loong64": "0.17.19", + "@esbuild/linux-mips64el": "0.17.19", + "@esbuild/linux-ppc64": "0.17.19", + "@esbuild/linux-riscv64": "0.17.19", + "@esbuild/linux-s390x": "0.17.19", + "@esbuild/linux-x64": "0.17.19", + "@esbuild/netbsd-x64": "0.17.19", + "@esbuild/openbsd-x64": "0.17.19", + "@esbuild/sunos-x64": "0.17.19", + "@esbuild/win32-arm64": "0.17.19", + "@esbuild/win32-ia32": "0.17.19", + "@esbuild/win32-x64": "0.17.19" + } + }, + "node_modules/escape-string-regexp": { + "version": "4.0.0", + "resolved": "https://registry.npmmirror.com/escape-string-regexp/-/escape-string-regexp-4.0.0.tgz", + "integrity": "sha512-TtpcNJ3XAzx3Gq8sWRzJaVajRs0uVxA2YAkdb1jm2YkPz4G6egUFAyA3n5vtEIZefPk5Wa4UXbKuS5fKkJWdgA==", + "dev": true, + "license": "MIT", + "engines": { + "node": ">=10" + }, + "funding": { + "url": "https://github.com/sponsors/sindresorhus" + } + }, + "node_modules/estree-walker": { + "version": "0.6.1", + "resolved": "https://registry.npmmirror.com/estree-walker/-/estree-walker-0.6.1.tgz", + "integrity": "sha512-SqmZANLWS0mnatqbSfRP5g8OXZC12Fgg1IwNtLsyHDzJizORW4khDfjPqJZsemPWBB2uqykUah5YpQ6epsqC/w==", + "dev": true, + "license": "MIT" + }, + "node_modules/exit-hook": { + "version": "2.2.1", + "resolved": "https://registry.npmmirror.com/exit-hook/-/exit-hook-2.2.1.tgz", + "integrity": "sha512-eNTPlAD67BmP31LDINZ3U7HSF8l57TxOY2PmBJ1shpCvpnxBF93mWCE8YHBnXs8qiUZJc9WDcWIeC3a2HIAMfw==", + "dev": true, + "license": "MIT", + "engines": { + "node": ">=6" + }, + "funding": { + "url": "https://github.com/sponsors/sindresorhus" + } + }, + "node_modules/exsolve": { + "version": "1.0.7", + "resolved": "https://registry.npmmirror.com/exsolve/-/exsolve-1.0.7.tgz", + "integrity": "sha512-VO5fQUzZtI6C+vx4w/4BWJpg3s/5l+6pRQEHzFRM8WFi4XffSP1Z+4qi7GbjWbvRQEbdIco5mIMq+zX4rPuLrw==", + "dev": true, + "license": "MIT" + }, + "node_modules/fetch-blob": { + "version": "3.2.0", + "resolved": "https://registry.npmmirror.com/fetch-blob/-/fetch-blob-3.2.0.tgz", + "integrity": "sha512-7yAQpD2UMJzLi1Dqv7qFYnPbaPx7ZfFK6PiIxQ4PfkGPyNyl2Ugx+a/umUonmKqjhM4DnfbMvdX6otXq83soQQ==", + "funding": [ + { + "type": "github", + "url": "https://github.com/sponsors/jimmywarting" + }, + { + "type": "paypal", + "url": "https://paypal.me/jimmywarting" + } + ], + "license": "MIT", + "dependencies": { + "node-domexception": "^1.0.0", + "web-streams-polyfill": "^3.0.3" + }, + "engines": { + "node": "^12.20 || >= 14.13" + } + }, + "node_modules/formdata-polyfill": { + "version": "4.0.10", + "resolved": "https://registry.npmmirror.com/formdata-polyfill/-/formdata-polyfill-4.0.10.tgz", + "integrity": "sha512-buewHzMvYL29jdeQTVILecSaZKnt/RJWjoZCF5OW60Z67/GmSLBkOFM7qh1PI3zFNtJbaZL5eQu1vLfazOwj4g==", + "license": "MIT", + "dependencies": { + "fetch-blob": "^3.1.2" + }, + "engines": { + "node": ">=12.20.0" + } + }, + "node_modules/fsevents": { + "version": "2.3.3", + "resolved": "https://registry.npmmirror.com/fsevents/-/fsevents-2.3.3.tgz", + "integrity": "sha512-5xoDfX+fL7faATnagmWPpbFtwh/R77WmMMqqHGS65C3vvB0YHrgF+B1YmZ3441tMj5n63k0212XNoJwzlhffQw==", + "dev": true, + "hasInstallScript": true, + "license": "MIT", + "optional": true, + "os": [ + "darwin" + ], + "engines": { + "node": "^8.16.0 || ^10.6.0 || >=11.0.0" + } + }, + "node_modules/get-source": { + "version": "2.0.12", + "resolved": "https://registry.npmmirror.com/get-source/-/get-source-2.0.12.tgz", + "integrity": "sha512-X5+4+iD+HoSeEED+uwrQ07BOQr0kEDFMVqqpBuI+RaZBpBpHCuXxo70bjar6f0b0u/DQJsJ7ssurpP0V60Az+w==", + "dev": true, + "license": "Unlicense", + "dependencies": { + "data-uri-to-buffer": "^2.0.0", + "source-map": "^0.6.1" + } + }, + "node_modules/glob-to-regexp": { + "version": "0.4.1", + "resolved": "https://registry.npmmirror.com/glob-to-regexp/-/glob-to-regexp-0.4.1.tgz", + "integrity": "sha512-lkX1HJXwyMcprw/5YUZc2s7DrpAiHB21/V+E1rHUrVNokkvB6bqMzT0VfV6/86ZNabt1k14YOIaT7nDvOX3Iiw==", + "dev": true, + "license": "BSD-2-Clause" + }, + "node_modules/is-arrayish": { + "version": "0.3.2", + "resolved": "https://registry.npmmirror.com/is-arrayish/-/is-arrayish-0.3.2.tgz", + "integrity": "sha512-eVRqCvVlZbuw3GrM63ovNSNAeA1K16kaR/LRY/92w0zxQ5/1YzwblUX652i4Xs9RwAGjW9d9y6X88t8OaAJfWQ==", + "dev": true, + "license": "MIT", + "optional": true + }, + "node_modules/magic-string": { + "version": "0.25.9", + "resolved": "https://registry.npmmirror.com/magic-string/-/magic-string-0.25.9.tgz", + "integrity": "sha512-RmF0AsMzgt25qzqqLc1+MbHmhdx0ojF2Fvs4XnOqz2ZOBXzzkEwc/dJQZCYHAn7v1jbVOjAZfK8msRn4BxO4VQ==", + "dev": true, + "license": "MIT", + "dependencies": { + "sourcemap-codec": "^1.4.8" + } + }, + "node_modules/mime": { + "version": "3.0.0", + "resolved": "https://registry.npmmirror.com/mime/-/mime-3.0.0.tgz", + "integrity": "sha512-jSCU7/VB1loIWBZe14aEYHU/+1UMEHoaO7qxCOVJOw9GgH72VAWppxNcjU+x9a2k3GSIBXNKxXQFqRvvZ7vr3A==", + "dev": true, + "license": "MIT", + "bin": { + "mime": "cli.js" + }, + "engines": { + "node": ">=10.0.0" + } + }, + "node_modules/miniflare": { + "version": "3.20250718.1", + "resolved": "https://registry.npmmirror.com/miniflare/-/miniflare-3.20250718.1.tgz", + "integrity": "sha512-9QAOHVKIVHmnQ1dJT9Fls8aVA8R5JjEizzV889Dinq/+bEPltqIepCvm9Z+fbNUgLvV7D/H1NUk8VdlLRgp9Wg==", + "dev": true, + "license": "MIT", + "dependencies": { + "@cspotcode/source-map-support": "0.8.1", + "acorn": "8.14.0", + "acorn-walk": "8.3.2", + "exit-hook": "2.2.1", + "glob-to-regexp": "0.4.1", + "stoppable": "1.1.0", + "undici": "^5.28.5", + "workerd": "1.20250718.0", + "ws": "8.18.0", + "youch": "3.3.4", + "zod": "3.22.3" + }, + "bin": { + "miniflare": "bootstrap.js" + }, + "engines": { + "node": ">=16.13" + } + }, + "node_modules/mustache": { + "version": "4.2.0", + "resolved": "https://registry.npmmirror.com/mustache/-/mustache-4.2.0.tgz", + "integrity": "sha512-71ippSywq5Yb7/tVYyGbkBggbU8H3u5Rz56fH60jGFgr8uHwxs+aSKeqmluIVzM0m0kB7xQjKS6qPfd0b2ZoqQ==", + "dev": true, + "license": "MIT", + "bin": { + "mustache": "bin/mustache" + } + }, + "node_modules/node-domexception": { + "version": "1.0.0", + "resolved": "https://registry.npmmirror.com/node-domexception/-/node-domexception-1.0.0.tgz", + "integrity": "sha512-/jKZoMpw0F8GRwl4/eLROPA3cfcXtLApP0QzLmUT/HuPCZWyB7IY9ZrMeKw2O/nFIqPQB3PVM9aYm0F312AXDQ==", + "deprecated": "Use your platform's native DOMException instead", + "funding": [ + { + "type": "github", + "url": "https://github.com/sponsors/jimmywarting" + }, + { + "type": "github", + "url": "https://paypal.me/jimmywarting" + } + ], + "license": "MIT", + "engines": { + "node": ">=10.5.0" + } + }, + "node_modules/node-fetch": { + "version": "3.3.2", + "resolved": "https://registry.npmmirror.com/node-fetch/-/node-fetch-3.3.2.tgz", + "integrity": "sha512-dRB78srN/l6gqWulah9SrxeYnxeddIG30+GOqK/9OlLVyLg3HPnr6SqOWTWOXKRwC2eGYCkZ59NNuSgvSrpgOA==", + "license": "MIT", + "dependencies": { + "data-uri-to-buffer": "^4.0.0", + "fetch-blob": "^3.1.4", + "formdata-polyfill": "^4.0.10" + }, + "engines": { + "node": "^12.20.0 || ^14.13.1 || >=16.0.0" + }, + "funding": { + "type": "opencollective", + "url": "https://opencollective.com/node-fetch" + } + }, + "node_modules/node-fetch/node_modules/data-uri-to-buffer": { + "version": "4.0.1", + "resolved": "https://registry.npmmirror.com/data-uri-to-buffer/-/data-uri-to-buffer-4.0.1.tgz", + "integrity": "sha512-0R9ikRb668HB7QDxT1vkpuUBtqc53YyAwMwGeUFKRojY/NWKvdZ+9UYtRfGmhqNbRkTSVpMbmyhXipFFv2cb/A==", + "license": "MIT", + "engines": { + "node": ">= 12" + } + }, + "node_modules/ohash": { + "version": "2.0.11", + "resolved": "https://registry.npmmirror.com/ohash/-/ohash-2.0.11.tgz", + "integrity": "sha512-RdR9FQrFwNBNXAr4GixM8YaRZRJ5PUWbKYbE5eOsrwAjJW0q2REGcf79oYPsLyskQCZG1PLN+S/K1V00joZAoQ==", + "dev": true, + "license": "MIT" + }, + "node_modules/path-to-regexp": { + "version": "6.3.0", + "resolved": "https://registry.npmmirror.com/path-to-regexp/-/path-to-regexp-6.3.0.tgz", + "integrity": "sha512-Yhpw4T9C6hPpgPeA28us07OJeqZ5EzQTkbfwuhsUg0c237RomFoETJgmp2sa3F/41gfLE6G5cqcYwznmeEeOlQ==", + "dev": true, + "license": "MIT" + }, + "node_modules/pathe": { + "version": "2.0.3", + "resolved": "https://registry.npmmirror.com/pathe/-/pathe-2.0.3.tgz", + "integrity": "sha512-WUjGcAqP1gQacoQe+OBJsFA7Ld4DyXuUIjZ5cc75cLHvJ7dtNsTugphxIADwspS+AraAUePCKrSVtPLFj/F88w==", + "dev": true, + "license": "MIT" + }, + "node_modules/pg": { + "version": "8.16.3", + "resolved": "https://registry.npmmirror.com/pg/-/pg-8.16.3.tgz", + "integrity": "sha512-enxc1h0jA/aq5oSDMvqyW3q89ra6XIIDZgCX9vkMrnz5DFTw/Ny3Li2lFQ+pt3L6MCgm/5o2o8HW9hiJji+xvw==", + "license": "MIT", + "dependencies": { + "pg-connection-string": "^2.9.1", + "pg-pool": "^3.10.1", + "pg-protocol": "^1.10.3", + "pg-types": "2.2.0", + "pgpass": "1.0.5" + }, + "engines": { + "node": ">= 16.0.0" + }, + "optionalDependencies": { + "pg-cloudflare": "^1.2.7" + }, + "peerDependencies": { + "pg-native": ">=3.0.1" + }, + "peerDependenciesMeta": { + "pg-native": { + "optional": true + } + } + }, + "node_modules/pg-cloudflare": { + "version": "1.2.7", + "resolved": "https://registry.npmmirror.com/pg-cloudflare/-/pg-cloudflare-1.2.7.tgz", + "integrity": "sha512-YgCtzMH0ptvZJslLM1ffsY4EuGaU0cx4XSdXLRFae8bPP4dS5xL1tNB3k2o/N64cHJpwU7dxKli/nZ2lUa5fLg==", + "license": "MIT", + "optional": true + }, + "node_modules/pg-connection-string": { + "version": "2.9.1", + "resolved": "https://registry.npmmirror.com/pg-connection-string/-/pg-connection-string-2.9.1.tgz", + "integrity": "sha512-nkc6NpDcvPVpZXxrreI/FOtX3XemeLl8E0qFr6F2Lrm/I8WOnaWNhIPK2Z7OHpw7gh5XJThi6j6ppgNoaT1w4w==", + "license": "MIT" + }, + "node_modules/pg-int8": { + "version": "1.0.1", + "resolved": "https://registry.npmmirror.com/pg-int8/-/pg-int8-1.0.1.tgz", + "integrity": "sha512-WCtabS6t3c8SkpDBUlb1kjOs7l66xsGdKpIPZsg4wR+B3+u9UAum2odSsF9tnvxg80h4ZxLWMy4pRjOsFIqQpw==", + "license": "ISC", + "engines": { + "node": ">=4.0.0" + } + }, + "node_modules/pg-pool": { + "version": "3.10.1", + "resolved": "https://registry.npmmirror.com/pg-pool/-/pg-pool-3.10.1.tgz", + "integrity": "sha512-Tu8jMlcX+9d8+QVzKIvM/uJtp07PKr82IUOYEphaWcoBhIYkoHpLXN3qO59nAI11ripznDsEzEv8nUxBVWajGg==", + "license": "MIT", + "peerDependencies": { + "pg": ">=8.0" + } + }, + "node_modules/pg-protocol": { + "version": "1.10.3", + "resolved": "https://registry.npmmirror.com/pg-protocol/-/pg-protocol-1.10.3.tgz", + "integrity": "sha512-6DIBgBQaTKDJyxnXaLiLR8wBpQQcGWuAESkRBX/t6OwA8YsqP+iVSiond2EDy6Y/dsGk8rh/jtax3js5NeV7JQ==", + "license": "MIT" + }, + "node_modules/pg-types": { + "version": "2.2.0", + "resolved": "https://registry.npmmirror.com/pg-types/-/pg-types-2.2.0.tgz", + "integrity": "sha512-qTAAlrEsl8s4OiEQY69wDvcMIdQN6wdz5ojQiOy6YRMuynxenON0O5oCpJI6lshc6scgAY8qvJ2On/p+CXY0GA==", + "license": "MIT", + "dependencies": { + "pg-int8": "1.0.1", + "postgres-array": "~2.0.0", + "postgres-bytea": "~1.0.0", + "postgres-date": "~1.0.4", + "postgres-interval": "^1.1.0" + }, + "engines": { + "node": ">=4" + } + }, + "node_modules/pgpass": { + "version": "1.0.5", + "resolved": "https://registry.npmmirror.com/pgpass/-/pgpass-1.0.5.tgz", + "integrity": "sha512-FdW9r/jQZhSeohs1Z3sI1yxFQNFvMcnmfuj4WBMUTxOrAyLMaTcE1aAMBiTlbMNaXvBCQuVi0R7hd8udDSP7ug==", + "license": "MIT", + "dependencies": { + "split2": "^4.1.0" + } + }, + "node_modules/postgres-array": { + "version": "2.0.0", + "resolved": "https://registry.npmmirror.com/postgres-array/-/postgres-array-2.0.0.tgz", + "integrity": "sha512-VpZrUqU5A69eQyW2c5CA1jtLecCsN2U/bD6VilrFDWq5+5UIEVO7nazS3TEcHf1zuPYO/sqGvUvW62g86RXZuA==", + "license": "MIT", + "engines": { + "node": ">=4" + } + }, + "node_modules/postgres-bytea": { + "version": "1.0.0", + "resolved": "https://registry.npmmirror.com/postgres-bytea/-/postgres-bytea-1.0.0.tgz", + "integrity": "sha512-xy3pmLuQqRBZBXDULy7KbaitYqLcmxigw14Q5sj8QBVLqEwXfeybIKVWiqAXTlcvdvb0+xkOtDbfQMOf4lST1w==", + "license": "MIT", + "engines": { + "node": ">=0.10.0" + } + }, + "node_modules/postgres-date": { + "version": "1.0.7", + "resolved": "https://registry.npmmirror.com/postgres-date/-/postgres-date-1.0.7.tgz", + "integrity": "sha512-suDmjLVQg78nMK2UZ454hAG+OAW+HQPZ6n++TNDUX+L0+uUlLywnoxJKDou51Zm+zTCjrCl0Nq6J9C5hP9vK/Q==", + "license": "MIT", + "engines": { + "node": ">=0.10.0" + } + }, + "node_modules/postgres-interval": { + "version": "1.2.0", + "resolved": "https://registry.npmmirror.com/postgres-interval/-/postgres-interval-1.2.0.tgz", + "integrity": "sha512-9ZhXKM/rw350N1ovuWHbGxnGh/SNJ4cnxHiM0rxE4VN41wsg8P8zWn9hv/buK00RP4WvlOyr/RBDiptyxVbkZQ==", + "license": "MIT", + "dependencies": { + "xtend": "^4.0.0" + }, + "engines": { + "node": ">=0.10.0" + } + }, + "node_modules/printable-characters": { + "version": "1.0.42", + "resolved": "https://registry.npmmirror.com/printable-characters/-/printable-characters-1.0.42.tgz", + "integrity": "sha512-dKp+C4iXWK4vVYZmYSd0KBH5F/h1HoZRsbJ82AVKRO3PEo8L4lBS/vLwhVtpwwuYcoIsVY+1JYKR268yn480uQ==", + "dev": true, + "license": "Unlicense" + }, + "node_modules/rollup-plugin-inject": { + "version": "3.0.2", + "resolved": "https://registry.npmmirror.com/rollup-plugin-inject/-/rollup-plugin-inject-3.0.2.tgz", + "integrity": "sha512-ptg9PQwzs3orn4jkgXJ74bfs5vYz1NCZlSQMBUA0wKcGp5i5pA1AO3fOUEte8enhGUC+iapTCzEWw2jEFFUO/w==", + "deprecated": "This package has been deprecated and is no longer maintained. Please use @rollup/plugin-inject.", + "dev": true, + "license": "MIT", + "dependencies": { + "estree-walker": "^0.6.1", + "magic-string": "^0.25.3", + "rollup-pluginutils": "^2.8.1" + } + }, + "node_modules/rollup-plugin-node-polyfills": { + "version": "0.2.1", + "resolved": "https://registry.npmmirror.com/rollup-plugin-node-polyfills/-/rollup-plugin-node-polyfills-0.2.1.tgz", + "integrity": "sha512-4kCrKPTJ6sK4/gLL/U5QzVT8cxJcofO0OU74tnB19F40cmuAKSzH5/siithxlofFEjwvw1YAhPmbvGNA6jEroA==", + "dev": true, + "license": "MIT", + "dependencies": { + "rollup-plugin-inject": "^3.0.0" + } + }, + "node_modules/rollup-pluginutils": { + "version": "2.8.2", + "resolved": "https://registry.npmmirror.com/rollup-pluginutils/-/rollup-pluginutils-2.8.2.tgz", + "integrity": "sha512-EEp9NhnUkwY8aif6bxgovPHMoMoNr2FulJziTndpt5H9RdwC47GSGuII9XxpSdzVGM0GWrNPHV6ie1LTNJPaLQ==", + "dev": true, + "license": "MIT", + "dependencies": { + "estree-walker": "^0.6.1" + } + }, + "node_modules/semver": { + "version": "7.7.2", + "resolved": "https://registry.npmmirror.com/semver/-/semver-7.7.2.tgz", + "integrity": "sha512-RF0Fw+rO5AMf9MAyaRXI4AV0Ulj5lMHqVxxdSgiVbixSCXoEmmX/jk0CuJw4+3SqroYO9VoUh+HcuJivvtJemA==", + "dev": true, + "license": "ISC", + "optional": true, + "bin": { + "semver": "bin/semver.js" + }, + "engines": { + "node": ">=10" + } + }, + "node_modules/sharp": { + "version": "0.33.5", + "resolved": "https://registry.npmmirror.com/sharp/-/sharp-0.33.5.tgz", + "integrity": "sha512-haPVm1EkS9pgvHrQ/F3Xy+hgcuMV0Wm9vfIBSiwZ05k+xgb0PkBQpGsAA/oWdDobNaZTH5ppvHtzCFbnSEwHVw==", + "dev": true, + "hasInstallScript": true, + "license": "Apache-2.0", + "optional": true, + "dependencies": { + "color": "^4.2.3", + "detect-libc": "^2.0.3", + "semver": "^7.6.3" + }, + "engines": { + "node": "^18.17.0 || ^20.3.0 || >=21.0.0" + }, + "funding": { + "url": "https://opencollective.com/libvips" + }, + "optionalDependencies": { + "@img/sharp-darwin-arm64": "0.33.5", + "@img/sharp-darwin-x64": "0.33.5", + "@img/sharp-libvips-darwin-arm64": "1.0.4", + "@img/sharp-libvips-darwin-x64": "1.0.4", + "@img/sharp-libvips-linux-arm": "1.0.5", + "@img/sharp-libvips-linux-arm64": "1.0.4", + "@img/sharp-libvips-linux-s390x": "1.0.4", + "@img/sharp-libvips-linux-x64": "1.0.4", + "@img/sharp-libvips-linuxmusl-arm64": "1.0.4", + "@img/sharp-libvips-linuxmusl-x64": "1.0.4", + "@img/sharp-linux-arm": "0.33.5", + "@img/sharp-linux-arm64": "0.33.5", + "@img/sharp-linux-s390x": "0.33.5", + "@img/sharp-linux-x64": "0.33.5", + "@img/sharp-linuxmusl-arm64": "0.33.5", + "@img/sharp-linuxmusl-x64": "0.33.5", + "@img/sharp-wasm32": "0.33.5", + "@img/sharp-win32-ia32": "0.33.5", + "@img/sharp-win32-x64": "0.33.5" + } + }, + "node_modules/simple-swizzle": { + "version": "0.2.2", + "resolved": "https://registry.npmmirror.com/simple-swizzle/-/simple-swizzle-0.2.2.tgz", + "integrity": "sha512-JA//kQgZtbuY83m+xT+tXJkmJncGMTFT+C+g2h2R9uxkYIrE2yy9sgmcLhCnw57/WSD+Eh3J97FPEDFnbXnDUg==", + "dev": true, + "license": "MIT", + "optional": true, + "dependencies": { + "is-arrayish": "^0.3.1" + } + }, + "node_modules/source-map": { + "version": "0.6.1", + "resolved": "https://registry.npmmirror.com/source-map/-/source-map-0.6.1.tgz", + "integrity": "sha512-UjgapumWlbMhkBgzT7Ykc5YXUT46F0iKu8SGXq0bcwP5dz/h0Plj6enJqjz1Zbq2l5WaqYnrVbwWOWMyF3F47g==", + "dev": true, + "license": "BSD-3-Clause", + "engines": { + "node": ">=0.10.0" + } + }, + "node_modules/sourcemap-codec": { + "version": "1.4.8", + "resolved": "https://registry.npmmirror.com/sourcemap-codec/-/sourcemap-codec-1.4.8.tgz", + "integrity": "sha512-9NykojV5Uih4lgo5So5dtw+f0JgJX30KCNI8gwhz2J9A15wD0Ml6tjHKwf6fTSa6fAdVBdZeNOs9eJ71qCk8vA==", + "deprecated": "Please use @jridgewell/sourcemap-codec instead", + "dev": true, + "license": "MIT" + }, + "node_modules/split2": { + "version": "4.2.0", + "resolved": "https://registry.npmmirror.com/split2/-/split2-4.2.0.tgz", + "integrity": "sha512-UcjcJOWknrNkF6PLX83qcHM6KHgVKNkV62Y8a5uYDVv9ydGQVwAHMKqHdJje1VTWpljG0WYpCDhrCdAOYH4TWg==", + "license": "ISC", + "engines": { + "node": ">= 10.x" + } + }, + "node_modules/stacktracey": { + "version": "2.1.8", + "resolved": "https://registry.npmmirror.com/stacktracey/-/stacktracey-2.1.8.tgz", + "integrity": "sha512-Kpij9riA+UNg7TnphqjH7/CzctQ/owJGNbFkfEeve4Z4uxT5+JapVLFXcsurIfN34gnTWZNJ/f7NMG0E8JDzTw==", + "dev": true, + "license": "Unlicense", + "dependencies": { + "as-table": "^1.0.36", + "get-source": "^2.0.12" + } + }, + "node_modules/stoppable": { + "version": "1.1.0", + "resolved": "https://registry.npmmirror.com/stoppable/-/stoppable-1.1.0.tgz", + "integrity": "sha512-KXDYZ9dszj6bzvnEMRYvxgeTHU74QBFL54XKtP3nyMuJ81CFYtABZ3bAzL2EdFUaEwJOBOgENyFj3R7oTzDyyw==", + "dev": true, + "license": "MIT", + "engines": { + "node": ">=4", + "npm": ">=6" + } + }, + "node_modules/tslib": { + "version": "2.8.1", + "resolved": "https://registry.npmmirror.com/tslib/-/tslib-2.8.1.tgz", + "integrity": "sha512-oJFu94HQb+KVduSUQL7wnpmqnfmLsOA/nAh6b6EH0wCEoK0/mPeXU6c3wKDV83MkOuHPRHtSXKKU99IBazS/2w==", + "dev": true, + "license": "0BSD", + "optional": true + }, + "node_modules/typescript": { + "version": "5.9.2", + "resolved": "https://registry.npmmirror.com/typescript/-/typescript-5.9.2.tgz", + "integrity": "sha512-CWBzXQrc/qOkhidw1OzBTQuYRbfyxDXJMVJ1XNwUHGROVmuaeiEm3OslpZ1RV96d7SKKjZKrSJu3+t/xlw3R9A==", + "dev": true, + "license": "Apache-2.0", + "bin": { + "tsc": "bin/tsc", + "tsserver": "bin/tsserver" + }, + "engines": { + "node": ">=14.17" + } + }, + "node_modules/ufo": { + "version": "1.6.1", + "resolved": "https://registry.npmmirror.com/ufo/-/ufo-1.6.1.tgz", + "integrity": "sha512-9a4/uxlTWJ4+a5i0ooc1rU7C7YOw3wT+UGqdeNNHWnOF9qcMBgLRS+4IYUqbczewFx4mLEig6gawh7X6mFlEkA==", + "dev": true, + "license": "MIT" + }, + "node_modules/undici": { + "version": "5.29.0", + "resolved": "https://registry.npmmirror.com/undici/-/undici-5.29.0.tgz", + "integrity": "sha512-raqeBD6NQK4SkWhQzeYKd1KmIG6dllBOTt55Rmkt4HtI9mwdWtJljnrXjAFUBLTSN67HWrOIZ3EPF4kjUw80Bg==", + "dev": true, + "license": "MIT", + "dependencies": { + "@fastify/busboy": "^2.0.0" + }, + "engines": { + "node": ">=14.0" + } + }, + "node_modules/undici-types": { + "version": "6.21.0", + "resolved": "https://registry.npmmirror.com/undici-types/-/undici-types-6.21.0.tgz", + "integrity": "sha512-iwDZqg0QAGrg9Rav5H4n0M64c3mkR59cJ6wQp+7C4nI0gsmExaedaYLNO44eT4AtBBwjbTiGPMlt2Md0T9H9JQ==", + "dev": true, + "license": "MIT" + }, + "node_modules/unenv": { + "version": "2.0.0-rc.14", + "resolved": "https://registry.npmmirror.com/unenv/-/unenv-2.0.0-rc.14.tgz", + "integrity": "sha512-od496pShMen7nOy5VmVJCnq8rptd45vh6Nx/r2iPbrba6pa6p+tS2ywuIHRZ/OBvSbQZB0kWvpO9XBNVFXHD3Q==", + "dev": true, + "license": "MIT", + "dependencies": { + "defu": "^6.1.4", + "exsolve": "^1.0.1", + "ohash": "^2.0.10", + "pathe": "^2.0.3", + "ufo": "^1.5.4" + } + }, + "node_modules/web-streams-polyfill": { + "version": "3.3.3", + "resolved": "https://registry.npmmirror.com/web-streams-polyfill/-/web-streams-polyfill-3.3.3.tgz", + "integrity": "sha512-d2JWLCivmZYTSIoge9MsgFCZrt571BikcWGYkjC1khllbTeDlGqZ2D8vD8E/lJa8WGWbb7Plm8/XJYV7IJHZZw==", + "license": "MIT", + "engines": { + "node": ">= 8" + } + }, + "node_modules/workerd": { + "version": "1.20250718.0", + "resolved": "https://registry.npmmirror.com/workerd/-/workerd-1.20250718.0.tgz", + "integrity": "sha512-kqkIJP/eOfDlUyBzU7joBg+tl8aB25gEAGqDap+nFWb+WHhnooxjGHgxPBy3ipw2hnShPFNOQt5lFRxbwALirg==", + "dev": true, + "hasInstallScript": true, + "license": "Apache-2.0", + "bin": { + "workerd": "bin/workerd" + }, + "engines": { + "node": ">=16" + }, + "optionalDependencies": { + "@cloudflare/workerd-darwin-64": "1.20250718.0", + "@cloudflare/workerd-darwin-arm64": "1.20250718.0", + "@cloudflare/workerd-linux-64": "1.20250718.0", + "@cloudflare/workerd-linux-arm64": "1.20250718.0", + "@cloudflare/workerd-windows-64": "1.20250718.0" + } + }, + "node_modules/wrangler": { + "version": "3.114.13", + "resolved": "https://registry.npmmirror.com/wrangler/-/wrangler-3.114.13.tgz", + "integrity": "sha512-bJbKJGTjClEp5XeyjiIKXodHW6j14ZsXuMphjvTZSwkQjGg6QlOol74/44d/u1Uso+hhIzYFg6m/d/1ggxUqWQ==", + "dev": true, + "license": "MIT OR Apache-2.0", + "dependencies": { + "@cloudflare/kv-asset-handler": "0.3.4", + "@cloudflare/unenv-preset": "2.0.2", + "@esbuild-plugins/node-globals-polyfill": "0.2.3", + "@esbuild-plugins/node-modules-polyfill": "0.2.2", + "blake3-wasm": "2.1.5", + "esbuild": "0.17.19", + "miniflare": "3.20250718.1", + "path-to-regexp": "6.3.0", + "unenv": "2.0.0-rc.14", + "workerd": "1.20250718.0" + }, + "bin": { + "wrangler": "bin/wrangler.js", + "wrangler2": "bin/wrangler.js" + }, + "engines": { + "node": ">=16.17.0" + }, + "optionalDependencies": { + "fsevents": "~2.3.2", + "sharp": "^0.33.5" + }, + "peerDependencies": { + "@cloudflare/workers-types": "^4.20250408.0" + }, + "peerDependenciesMeta": { + "@cloudflare/workers-types": { + "optional": true + } + } + }, + "node_modules/ws": { + "version": "8.18.0", + "resolved": "https://registry.npmmirror.com/ws/-/ws-8.18.0.tgz", + "integrity": "sha512-8VbfWfHLbbwu3+N6OKsOMpBdT4kXPDDB9cJk2bJ6mh9ucxdlnNvH1e+roYkKmN9Nxw2yjz7VzeO9oOz2zJ04Pw==", + "dev": true, + "license": "MIT", + "engines": { + "node": ">=10.0.0" + }, + "peerDependencies": { + "bufferutil": "^4.0.1", + "utf-8-validate": ">=5.0.2" + }, + "peerDependenciesMeta": { + "bufferutil": { + "optional": true + }, + "utf-8-validate": { + "optional": true + } + } + }, + "node_modules/xtend": { + "version": "4.0.2", + "resolved": "https://registry.npmmirror.com/xtend/-/xtend-4.0.2.tgz", + "integrity": "sha512-LKYU1iAXJXUgAXn9URjiu+MWhyUXHsvfp7mcuYm9dSUKK0/CjtrUwFAxD82/mCWbtLsGjFIad0wIsod4zrTAEQ==", + "license": "MIT", + "engines": { + "node": ">=0.4" + } + }, + "node_modules/youch": { + "version": "3.3.4", + "resolved": "https://registry.npmmirror.com/youch/-/youch-3.3.4.tgz", + "integrity": "sha512-UeVBXie8cA35DS6+nBkls68xaBBXCye0CNznrhszZjTbRVnJKQuNsyLKBTTL4ln1o1rh2PKtv35twV7irj5SEg==", + "dev": true, + "license": "MIT", + "dependencies": { + "cookie": "^0.7.1", + "mustache": "^4.2.0", + "stacktracey": "^2.1.8" + } + }, + "node_modules/zod": { + "version": "3.22.3", + "resolved": "https://registry.npmmirror.com/zod/-/zod-3.22.3.tgz", + "integrity": "sha512-EjIevzuJRiRPbVH4mGc8nApb/lVLKVpmUhAaR5R5doKGfAnGJ6Gr3CViAVjP+4FWSxCsybeWQdcgCtbX+7oZug==", + "dev": true, + "license": "MIT", + "funding": { + "url": "https://github.com/sponsors/colinhacks" + } + } + } +} diff --git a/package.json b/package.json new file mode 100644 index 0000000..feed0e2 --- /dev/null +++ b/package.json @@ -0,0 +1,31 @@ +{ + "name": "hyperdrive-neondb-test", + "version": "1.0.0", + "description": "Cloudflare Worker to test Hyperdrive connection with NeonDB", + "main": "src/index.ts", + "scripts": { + "dev": "wrangler dev", + "deploy": "wrangler deploy", + "test": "wrangler dev --local" + }, + "dependencies": { + "node-fetch": "^3.3.2", + "pg": "^8.11.3" + }, + "devDependencies": { + "@cloudflare/workers-types": "^4.20240129.0", + "@types/node": "^20.11.16", + "@types/pg": "^8.10.9", + "typescript": "^5.3.3", + "wrangler": "^3.28.2" + }, + "keywords": [ + "cloudflare", + "workers", + "hyperdrive", + "neondb", + "postgresql" + ], + "author": "", + "license": "MIT" +} diff --git a/qczh_debate_state.json b/qczh_debate_state.json new file mode 100644 index 0000000..ed26813 --- /dev/null +++ b/qczh_debate_state.json @@ -0,0 +1,39 @@ +{ + "current_stage": "起", + "stage_progress": 4, + "total_handoffs": 0, + "debate_history": [ + { + "timestamp": "2025-08-10T15:30:47.514243", + "stage": "起", + "progress": 0, + "speaker": "吕洞宾", + "message": "起：八仙按先天八卦顺序阐述观点", + "handoffs": 0 + }, + { + "timestamp": "2025-08-10T15:30:47.514260", + "stage": "起", + "progress": 1, + "speaker": "何仙姑", + "message": "承：雁阵式承接，总体阐述+讥讽", + "handoffs": 0 + }, + { + "timestamp": "2025-08-10T15:30:47.514272", + "stage": "起", + "progress": 2, + "speaker": "铁拐李", + "message": "转：自由辩论，36次handoff", + "handoffs": 0 + }, + { + "timestamp": "2025-08-10T15:30:47.514281", + "stage": "起", + "progress": 3, + "speaker": "汉钟离", + "message": "合：交替总结，最终论证", + "handoffs": 0 + } + ] +} \ No newline at end of file diff --git a/query-shushu-book.js b/query-shushu-book.js new file mode 100644 index 0000000..3fd5e92 --- /dev/null +++ b/query-shushu-book.js @@ -0,0 +1,138 @@ +// 查询术数书内容的脚本 +// 通过 Hyperdrive API 查询 NeonDB 中的术数书数据 + +const API_BASE_URL = 'https://hyperdrive.seekkey.tech'; + +// 通用请求函数 +async function apiRequest(endpoint, options = {}) { + const url = `${API_BASE_URL}${endpoint}`; + const headers = { + 'Content-Type': 'application/json', + ...options.headers + }; + + try { + const response = await fetch(url, { + ...options, + headers + }); + + if (!response.ok) { + throw new Error(`HTTP ${response.status}: ${response.statusText}`); + } + + const contentType = response.headers.get('content-type'); + if (contentType && contentType.includes('application/json')) { + return await response.json(); + } else { + return await response.text(); + } + } catch (error) { + console.error(`Request failed for ${endpoint}:`, error.message); + throw error; + } +} + +// 查询数据库表结构 +async function queryTables() { + console.log('\n📋 查询数据库表结构...'); + try { + const result = await apiRequest('/query-tables'); + console.log('✅ 数据库表:', result); + return result; + } catch (error) { + console.log('❌ 查询表结构失败:', error.message); + return null; + } +} + +// 查询术数书内容 +async function queryShushuBook(limit = 10) { + console.log('\n📚 查询术数书内容...'); + try { + const result = await apiRequest(`/query-shushu?limit=${limit}`); + console.log('✅ 术数书内容:', JSON.stringify(result, null, 2)); + return result; + } catch (error) { + console.log('❌ 查询术数书失败:', error.message); + return null; + } +} + +// 搜索术数书内容 +async function searchShushuBook(keyword, limit = 5) { + console.log(`\n🔍 搜索术数书内容: "${keyword}"...`); + try { + const result = await apiRequest(`/search-shushu?q=${encodeURIComponent(keyword)}&limit=${limit}`); + console.log('✅ 搜索结果:', JSON.stringify(result, null, 2)); + return result; + } catch (error) { + console.log('❌ 搜索失败:', error.message); + return null; + } +} + +// 获取术数书统计信息 +async function getShushuStats() { + console.log('\n📊 获取术数书统计信息...'); + try { + const result = await apiRequest('/shushu-stats'); + console.log('✅ 统计信息:', JSON.stringify(result, null, 2)); + return result; + } catch (error) { + console.log('❌ 获取统计信息失败:', error.message); + return null; + } +} + +// 主函数 +async function main() { + console.log('🚀 术数书查询脚本'); + console.log('=================='); + + // 首先测试连接 + console.log('\n🔗 测试 Hyperdrive 连接...'); + try { + const connectionTest = await apiRequest('/test-connection'); + console.log('✅ 连接成功:', connectionTest.message); + } catch (error) { + console.log('❌ 连接失败:', error.message); + return; + } + + // 查询表结构 + await queryTables(); + + // 获取统计信息 + await getShushuStats(); + + // 查询术数书内容 + await queryShushuBook(5); + + // 搜索示例 + await searchShushuBook('易经'); + await searchShushuBook('八卦'); + await searchShushuBook('太公'); +} + +// 如果是 Node.js 环境，导入 fetch +if (typeof window === 'undefined') { + // Node.js 环境 + const { default: fetch } = require('node-fetch'); + global.fetch = fetch; + main().catch(console.error); +} else { + // 浏览器环境 + console.log('在浏览器控制台中运行: main()'); +} + +// 导出函数供其他模块使用 +if (typeof module !== 'undefined' && module.exports) { + module.exports = { + queryTables, + queryShushuBook, + searchShushuBook, + getShushuStats, + main + }; +} \ No newline at end of file diff --git a/requirements.txt b/requirements.txt index 8b4fee4..be727df 100644 --- a/requirements.txt +++ b/requirements.txt @@ -13,13 +13,19 @@ plotly>=5.15.0 # HTTP请求 requests>=2.31.0 +aiohttp>=3.8.0 +# Cloudflare (HTTP 调用即可，无需额外 SDK) + + +# RSS解析 +feedparser>=6.0.0 # 类型注解支持 typing-extensions>=4.7.0 -# 数据库连接 (可选) +# 数据库连接 # sqlalchemy>=2.0.0 -# pymongo>=4.5.0 +pymongo>=4.5.0 # pymilvus>=2.3.0 # 开发工具 (可选) @@ -28,8 +34,16 @@ typing-extensions>=4.7.0 # flake8>=6.0.0 # AI模型接口 +# 旧系统：OpenRouter + OpenAI Swarm openai>=1.0.0 # anthropic>=0.3.0 -# OpenAI Swarm (从GitHub安装) +# 新系统：Google ADK (根据迁移进度选择) +# pip install google-adk +# 或开发版: pip install git+https://github.com/google/adk-python.git@main + +# Vertex AI Memory Bank 支持 +google-cloud-aiplatform>=1.38.0 + +# OpenAI Swarm (保留兼容性，逐步替换) # pip install git+https://github.com/openai/swarm.git \ No newline at end of file diff --git a/rss_news_collector.py b/rss_news_collector.py deleted file mode 100644 index 8c1f9f1..0000000 --- a/rss_news_collector.py +++ /dev/null @@ -1,268 +0,0 @@ -#!/usr/bin/env python3 -""" -RSS新闻收集器 -收集RSS新闻并存储到MongoDB，为辩论系统提供数据源 -""" - -import asyncio -import feedparser -import json -import logging -from datetime import datetime, timezone -from typing import Dict, List, Any, Optional -from urllib.parse import urlparse -import hashlib -import requests -from src.mcp.swarm_mongodb_client import SwarmMongoDBClient - -class RSSNewsCollector: - """RSS新闻收集器""" - - def __init__(self, mongodb_client: SwarmMongoDBClient): - self.mongodb_client = mongodb_client - self.logger = logging.getLogger(__name__) - - # 默认RSS源配置 - self.rss_sources = { - '财经新闻': [ - 'https://feeds.finance.yahoo.com/rss/2.0/headline', - 'https://www.cnbc.com/id/100003114/device/rss/rss.html', - 'https://feeds.reuters.com/reuters/businessNews' - ], - '科技新闻': [ - 'https://feeds.feedburner.com/TechCrunch', - 'https://www.wired.com/feed/rss', - 'https://feeds.arstechnica.com/arstechnica/index' - ], - '市场分析': [ - 'https://feeds.marketwatch.com/marketwatch/marketpulse/', - 'https://feeds.bloomberg.com/markets/news.rss' - ] - } - - def generate_article_id(self, url: str, title: str) -> str: - """生成文章唯一ID""" - content = f"{url}_{title}" - return hashlib.md5(content.encode()).hexdigest() - - def parse_rss_feed(self, rss_url: str) -> List[Dict[str, Any]]: - """解析RSS源""" - try: - feed = feedparser.parse(rss_url) - articles = [] - - for entry in feed.entries: - # 提取文章信息 - article = { - 'article_id': self.generate_article_id(entry.link, entry.title), - 'title': entry.title, - 'link': entry.link, - 'description': getattr(entry, 'description', ''), - 'summary': getattr(entry, 'summary', ''), - 'published': self._parse_date(getattr(entry, 'published', '')), - 'author': getattr(entry, 'author', ''), - 'tags': [tag.term for tag in getattr(entry, 'tags', [])], - 'source_url': rss_url, - 'source_title': feed.feed.get('title', ''), - 'collected_at': datetime.now(timezone.utc), - 'content_hash': hashlib.md5(entry.title.encode()).hexdigest() - } - articles.append(article) - - return articles - - except Exception as e: - self.logger.error(f"解析RSS源失败 {rss_url}: {e}") - return [] - - def _parse_date(self, date_str: str) -> Optional[datetime]: - """解析日期字符串""" - if not date_str: - return None - - try: - # feedparser通常会解析时间 - import time - parsed_time = feedparser._parse_date(date_str) - if parsed_time: - return datetime.fromtimestamp(time.mktime(parsed_time), tz=timezone.utc) - except: - pass - - return datetime.now(timezone.utc) - - async def collect_news_from_category(self, category: str) -> List[Dict[str, Any]]: - """从指定类别收集新闻""" - if category not in self.rss_sources: - self.logger.warning(f"未知新闻类别: {category}") - return [] - - all_articles = [] - for rss_url in self.rss_sources[category]: - self.logger.info(f"正在收集新闻: {rss_url}") - articles = self.parse_rss_feed(rss_url) - - # 添加类别标签 - for article in articles: - article['category'] = category - - all_articles.extend(articles) - - return all_articles - - async def collect_all_news(self) -> Dict[str, List[Dict[str, Any]]]: - """收集所有类别的新闻""" - all_news = {} - - for category in self.rss_sources.keys(): - news = await self.collect_news_from_category(category) - all_news[category] = news - self.logger.info(f"收集到 {len(news)} 条 {category} 新闻") - - return all_news - - async def store_news_to_mongodb(self, articles: List[Dict[str, Any]], collection_name: str = "news_articles") -> Dict[str, Any]: - """将新闻存储到MongoDB""" - if not articles: - return {'success': True, 'inserted_count': 0, 'updated_count': 0} - - inserted_count = 0 - updated_count = 0 - - for article in articles: - # 检查文章是否已存在 - existing = self.mongodb_client.find_documents( - collection_name, - query={'article_id': article['article_id']}, - limit=1 - ) - - if existing.get('success') and existing.get('documents'): - # 更新现有文章 - update_result = self.mongodb_client.update_document( - collection_name, - query={'article_id': article['article_id']}, - update={'$set': article} - ) - if update_result.get('success'): - updated_count += 1 - else: - # 插入新文章 - insert_result = self.mongodb_client.insert_document( - collection_name, - document=article - ) - if insert_result.get('success'): - inserted_count += 1 - - return { - 'success': True, - 'inserted_count': inserted_count, - 'updated_count': updated_count, - 'total_processed': len(articles) - } - - async def get_latest_news(self, category: Optional[str] = None, limit: int = 10) -> List[Dict[str, Any]]: - """获取最新新闻""" - query = {} - if category: - query['category'] = category - - result = self.mongodb_client.find_documents( - 'news_articles', - query=query, - sort={'collected_at': -1}, - limit=limit - ) - - if result.get('success'): - return result.get('documents', []) - return [] - - async def get_news_for_debate(self, topic_keywords: List[str], limit: int = 5) -> List[Dict[str, Any]]: - """根据关键词获取相关新闻用于辩论""" - # 构建搜索查询 - search_conditions = [] - for keyword in topic_keywords: - search_conditions.extend([ - {'title': {'$regex': keyword, '$options': 'i'}}, - {'description': {'$regex': keyword, '$options': 'i'}}, - {'summary': {'$regex': keyword, '$options': 'i'}} - ]) - - query = {'$or': search_conditions} if search_conditions else {} - - result = self.mongodb_client.find_documents( - 'news_articles', - query=query, - sort={'published': -1}, - limit=limit - ) - - if result.get('success'): - return result.get('documents', []) - return [] - - async def run_collection_cycle(self): - """运行一次完整的新闻收集周期""" - self.logger.info("开始新闻收集周期") - - # 收集所有新闻 - all_news = await self.collect_all_news() - - # 存储到数据库 - total_inserted = 0 - total_updated = 0 - - for category, articles in all_news.items(): - if articles: - result = await self.store_news_to_mongodb(articles) - total_inserted += result.get('inserted_count', 0) - total_updated += result.get('updated_count', 0) - self.logger.info(f"{category}: 新增 {result.get('inserted_count', 0)}, 更新 {result.get('updated_count', 0)}") - - self.logger.info(f"新闻收集完成: 总新增 {total_inserted}, 总更新 {total_updated}") - - return { - 'success': True, - 'total_inserted': total_inserted, - 'total_updated': total_updated, - 'categories_processed': len(all_news) - } - -async def main(): - """主函数 - 演示RSS新闻收集""" - # 初始化MongoDB客户端 - mongodb_client = SwarmMongoDBClient( - mcp_server_url="http://localhost:8080", - default_database="news_debate_db" - ) - - # 连接数据库 - connect_result = mongodb_client.connect("news_debate_db") - if not connect_result.get('success'): - print(f"数据库连接失败: {connect_result}") - return - - # 创建新闻收集器 - collector = RSSNewsCollector(mongodb_client) - - # 运行收集周期 - result = await collector.run_collection_cycle() - print(f"收集结果: {result}") - - # 获取最新新闻示例 - latest_news = await collector.get_latest_news(limit=5) - print(f"\n最新新闻 ({len(latest_news)} 条):") - for news in latest_news: - print(f"- {news.get('title', 'N/A')} [{news.get('category', 'N/A')}]") - - # 根据关键词搜索新闻示例 - debate_news = await collector.get_news_for_debate(['投资', '市场', '经济'], limit=3) - print(f"\n辩论相关新闻 ({len(debate_news)} 条):") - for news in debate_news: - print(f"- {news.get('title', 'N/A')} [{news.get('category', 'N/A')}]") - -if __name__ == "__main__": - logging.basicConfig(level=logging.INFO) - asyncio.run(main()) \ No newline at end of file diff --git a/scripts/add_sequence_ids.py b/scripts/add_sequence_ids.py deleted file mode 100644 index ba274b7..0000000 --- a/scripts/add_sequence_ids.py +++ /dev/null @@ -1,63 +0,0 @@ -#!/usr/bin/env python3 -""" -为现有文章添加流水号 -""" - -import os -from pymongo import MongoClient - -def add_sequence_ids(): - """为现有文章添加流水号""" - # 连接MongoDB - mongo_uri = os.getenv('MONGODB_URI') - if not mongo_uri: - raise ValueError("MONGODB_URI environment variable is required") - client = MongoClient(mongo_uri) - db = client['taigong'] - collection = db['articles'] - - print("开始为现有文章添加流水号...") - - # 查找所有没有sequence_id的文章 - articles_without_seq = list(collection.find( - {"sequence_id": {"$exists": False}}, - {"_id": 1, "title": 1, "created_at": 1} - ).sort("created_at", 1)) # 按创建时间排序 - - print(f"找到 {len(articles_without_seq)} 篇文章需要添加流水号") - - if len(articles_without_seq) == 0: - print("所有文章都已有流水号") - return - - # 从1开始分配流水号 - for i, article in enumerate(articles_without_seq, 1): - sequence_id = i - article_id = f"NEWS_{sequence_id:08d}" # NEWS_00000001 格式 - - collection.update_one( - {"_id": article["_id"]}, - { - "$set": { - "sequence_id": sequence_id, - "article_id": article_id, - "batch_id": "migration_batch", - "last_updated": "2025-02-08T00:00:00Z" - } - } - ) - - print(f" {sequence_id:3d}: {article['title'][:50]}...") - - print(f"流水号添加完成，共处理 {len(articles_without_seq)} 篇文章") - - # 验证结果 - total_with_seq = collection.count_documents({"sequence_id": {"$exists": True}}) - max_seq = collection.find_one({}, sort=[("sequence_id", -1)]) - - print(f"验证结果:") - print(f" 有流水号的文章: {total_with_seq} 篇") - print(f" 最大流水号: {max_seq['sequence_id'] if max_seq else 0}") - -if __name__ == "__main__": - add_sequence_ids() \ No newline at end of file diff --git a/scripts/cleanup_duplicates.py b/scripts/cleanup_duplicates.py deleted file mode 100644 index 51601cb..0000000 --- a/scripts/cleanup_duplicates.py +++ /dev/null @@ -1,107 +0,0 @@ -#!/usr/bin/env python3 -""" -清理MongoDB中的重复文章数据 -""" - -import os -import sys -from pymongo import MongoClient -from collections import defaultdict -import hashlib - -def generate_stable_id(title, pub_date, content): - """生成稳定的文章ID""" - normalized_title = title.strip().lower() - content_hash = content[:100] if content else '' - date_str = pub_date or '' - - combined = f"{normalized_title}|{date_str}|{content_hash}" - return hashlib.md5(combined.encode()).hexdigest()[:16] - -def cleanup_duplicates(): - """清理重复数据""" - # 连接MongoDB - mongo_uri = os.getenv('MONGODB_URI') - if not mongo_uri: - raise ValueError("MONGODB_URI environment variable is required") - client = MongoClient(mongo_uri) - db = client['taigong'] - collection = db['articles'] - - print("开始清理重复数据...") - - # 1. 查找所有文章 - articles = list(collection.find({})) - print(f"总共找到 {len(articles)} 篇文章") - - # 2. 按标题分组，找出重复项 - title_groups = defaultdict(list) - for article in articles: - title_groups[article['title']].append(article) - - # 3. 处理重复项 - duplicates_removed = 0 - articles_updated = 0 - - for title, group in title_groups.items(): - if len(group) > 1: - print(f"发现重复标题: {title} ({len(group)} 篇)") - - # 保留最早的一篇，删除其他 - group.sort(key=lambda x: x.get('created_at', '')) - keep_article = group[0] - - # 更新保留文章的ID为稳定ID - stable_id = generate_stable_id( - keep_article['title'], - keep_article.get('published_time', ''), - keep_article.get('content', '') - ) - - collection.update_one( - {'_id': keep_article['_id']}, - { - '$set': { - 'article_id': stable_id, - 'content_hash': generate_stable_id(keep_article.get('content', ''), '', ''), - 'last_updated': '2025-02-08T00:00:00Z' - } - } - ) - articles_updated += 1 - - # 删除重复项 - for duplicate in group[1:]: - collection.delete_one({'_id': duplicate['_id']}) - duplicates_removed += 1 - print(f" 删除重复项: {duplicate.get('article_id', 'unknown')}") - - # 4. 为没有重复的文章更新ID - single_articles = [group[0] for group in title_groups.values() if len(group) == 1] - for article in single_articles: - if not article.get('article_id') or len(article.get('article_id', '')) > 20: - stable_id = generate_stable_id( - article['title'], - article.get('published_time', ''), - article.get('content', '') - ) - - collection.update_one( - {'_id': article['_id']}, - { - '$set': { - 'article_id': stable_id, - 'content_hash': generate_stable_id(article.get('content', ''), '', ''), - 'last_updated': '2025-02-08T00:00:00Z' - } - } - ) - articles_updated += 1 - - print(f"清理完成:") - print(f" 删除重复文章: {duplicates_removed} 篇") - print(f" 更新文章ID: {articles_updated} 篇") - print(f" 最终文章数: {collection.count_documents({})} 篇") - -if __name__ == "__main__": - cleanup_duplicates() \ No newline at end of file diff --git a/scripts/create_vector_index.js b/scripts/create_vector_index.js deleted file mode 100644 index 9cd7cba..0000000 --- a/scripts/create_vector_index.js +++ /dev/null @@ -1,35 +0,0 @@ -// MongoDB Atlas Vector Search Index Creation Script -// 为swarm辩论系统创建向量索引 - -// 连接到数据库 -use('taigong'); - -// 创建向量索引用于语义搜索和内容聚类 -// 这个索引将支持swarm辩论系统的语义相似性匹配 -db.articles.createSearchIndex( - "vector_search_index", - { - "fields": [ - { - "type": "vector", - "path": "embedding", - "numDimensions": 1536, // OpenAI text-embedding-ada-002 维度 - "similarity": "cosine" - }, - { - "type": "filter", - "path": "published_time" - }, - { - "type": "filter", - "path": "title" - } - ] - } -); - -print("向量索引创建完成！"); -print("索引名称: vector_search_index"); -print("向量维度: 1536 (OpenAI embedding)"); -print("相似性算法: cosine"); -print("支持过滤字段: published_time, title"); \ No newline at end of file diff --git a/scripts/generate_embeddings.py b/scripts/generate_embeddings.py deleted file mode 100644 index 67ceae3..0000000 --- a/scripts/generate_embeddings.py +++ /dev/null @@ -1,75 +0,0 @@ -#!/usr/bin/env python3 -""" -为MongoDB中的文章生成向量embeddings -用于swarm辩论系统的语义搜索和内容聚类 -""" - -import os -import openai -from pymongo import MongoClient -from typing import List, Dict -import time - -def get_mongodb_client(): - """从Doppler获取MongoDB连接""" - mongodb_uri = os.getenv('MONGODB_URI') - if not mongodb_uri: - raise ValueError("MONGODB_URI not found in environment variables") - return MongoClient(mongodb_uri) - -def generate_embedding(text: str) -> List[float]: - """使用OpenAI API生成文本embedding""" - try: - response = openai.Embedding.create( - model="text-embedding-ada-002", - input=text - ) - return response['data'][0]['embedding'] - except Exception as e: - print(f"生成embedding失败: {e}") - return None - -def update_articles_with_embeddings(): - """为所有文章添加embedding字段""" - client = get_mongodb_client() - db = client.taigong - collection = db.articles - - # 获取所有没有embedding的文章 - articles = collection.find({"embedding": {"$exists": False}}) - - count = 0 - for article in articles: - title = article.get('title', '') - if not title: - continue - - print(f"处理文章: {title[:50]}...") - - # 生成embedding - embedding = generate_embedding(title) - if embedding: - # 更新文档 - collection.update_one( - {"_id": article["_id"]}, - {"$set": {"embedding": embedding}} - ) - count += 1 - print(f"✓ 已更新 {count} 篇文章") - - # 避免API rate limit - time.sleep(0.1) - else: - print(f"× 跳过文章: {title[:50]}") - - print(f"\n完成！共处理 {count} 篇文章") - client.close() - -if __name__ == "__main__": - # 设置OpenAI API密钥 (应该从Doppler获取) - openai.api_key = os.getenv('OPENAI_API_KEY') - if not openai.api_key: - print("警告: OPENAI_API_KEY 未设置，请先在Doppler中配置") - exit(1) - - update_articles_with_embeddings() \ No newline at end of file diff --git a/scripts/install_swarm.py b/scripts/install_swarm.py deleted file mode 100644 index 5f44312..0000000 --- a/scripts/install_swarm.py +++ /dev/null @@ -1,73 +0,0 @@ -#!/usr/bin/env python3 -""" -安装OpenAI Swarm的脚本 -""" - -import subprocess -import sys - -def install_swarm(): - """安装OpenAI Swarm""" - print("🚀 正在安装OpenAI Swarm...") - - try: - # 安装Swarm - result = subprocess.run([ - sys.executable, "-m", "pip", "install", - "git+https://github.com/openai/swarm.git" - ], check=True, capture_output=True, text=True) - - print("✅ OpenAI Swarm安装成功！") - print(result.stdout) - - # 验证安装 - try: - import swarm - print("✅ Swarm导入测试成功") - print(f"📦 Swarm版本: {getattr(swarm, '__version__', '未知')}") - except ImportError as e: - print(f"❌ Swarm导入失败: {e}") - return False - - return True - - except subprocess.CalledProcessError as e: - print(f"❌ 安装失败: {e}") - print(f"错误输出: {e.stderr}") - return False - except Exception as e: - print(f"❌ 未知错误: {e}") - return False - -def main(): - """主函数""" - print("🏛️ 稷下学宫Swarm环境安装") - print("=" * 40) - - # 检查是否已安装 - try: - import swarm - print("✅ OpenAI Swarm已安装") - print(f"📦 版本: {getattr(swarm, '__version__', '未知')}") - - choice = input("是否重新安装？(y/N): ").strip().lower() - if choice not in ['y', 'yes']: - print("🎉 安装检查完成") - return - except ImportError: - print("📦 OpenAI Swarm未安装，开始安装...") - - # 安装Swarm - success = install_swarm() - - if success: - print("\n🎉 安装完成！现在可以使用Swarm八仙论道了") - print("💡 使用方法:") - print(" python src/jixia/debates/swarm_debate.py") - print(" 或在Streamlit应用中选择'Swarm模式'") - else: - print("\n❌ 安装失败，请手动安装:") - print(" pip install git+https://github.com/openai/swarm.git") - -if __name__ == "__main__": - main() \ No newline at end of file diff --git a/scripts/n8n_combined_dedup_insert.js b/scripts/n8n_combined_dedup_insert.js deleted file mode 100644 index a63c83e..0000000 --- a/scripts/n8n_combined_dedup_insert.js +++ /dev/null @@ -1,148 +0,0 @@ -const items = $input.all(); -const results = []; - -// 改进的哈希函数 - 基于内容生成稳定的ID -function generateStableId(title, pubDate, content) { - const normalizedTitle = title.trim().toLowerCase(); - const contentHash = content ? content.substring(0, 100) : ''; - const dateStr = pubDate || ''; - - const combined = normalizedTitle + '|' + dateStr + '|' + contentHash; - - let hash = 0; - for (let i = 0; i < combined.length; i++) { - const char = combined.charCodeAt(i); - hash = ((hash << 5) - hash) + char; - hash = hash & hash; - } - return Math.abs(hash).toString(16); -} - -console.log(`开始处理 ${items.length} 条RSS数据`); - -// 用于本次执行内去重 -const processedInThisRun = new Set(); - -// 处理每个RSS项目 -for (const item of items) { - const data = item.json; - - // 跳过无效数据 - if (!data.title) { - console.log('跳过无标题数据'); - continue; - } - - // 生成稳定的文章ID - const stableId = generateStableId( - data.title, - data.isoDate || data.pubDate, - data['content:encodedSnippet'] || data.contentSnippet || '' - ); - - // 生成内容哈希 - const contentHash = generateStableId( - data['content:encodedSnippet'] || data.contentSnippet || '', - '', - '' - ); - - // 准备文章数据 - const articleData = { - article_id: stableId, - title: data.title, - content: data['content:encodedSnippet'] || data.contentSnippet || '', - content_hash: contentHash, - published_time: data.isoDate || data.pubDate || new Date().toISOString(), - source_url: data.link || '', - processed: false, - created_at: new Date().toISOString(), - last_updated: new Date().toISOString() - }; - - try { - // 使用upsert操作，避免重复插入 - const result = await mongoClient.db('taigong').collection('articles').updateOne( - { - $or: [ - { article_id: stableId }, - { title: data.title } - ] - }, - { - $setOnInsert: { - article_id: stableId, - title: data.title, - content: articleData.content, - content_hash: contentHash, - published_time: articleData.published_time, - source_url: articleData.source_url, - processed: false, - created_at: articleData.created_at - }, - $set: { - last_updated: new Date().toISOString() - } - }, - { upsert: true } - ); - - if (result.upsertedCount > 0) { - console.log('✅ 新增文章:', data.title); - results.push({ - json: { - action: 'inserted', - article_id: stableId, - title: data.title, - status: 'success' - } - }); - } else if (result.modifiedCount > 0) { - console.log('🔄 更新文章:', data.title); - results.push({ - json: { - action: 'updated', - article_id: stableId, - title: data.title, - status: 'success' - } - }); - } else { - console.log('⏭️ 文章已存在，跳过:', data.title); - } - - } catch (error) { - console.error('❌ 处理文章失败:', data.title, error.message); - results.push({ - json: { - action: 'error', - title: data.title, - error: error.message, - status: 'failed' - } - }); - } -} - -console.log(`处理完成: 原始${items.length}条, 成功处理${results.length}条`); - -// 统计结果 -const stats = results.reduce((acc, item) => { - acc[item.json.action] = (acc[item.json.action] || 0) + 1; - return acc; -}, {}); - -console.log('处理统计:', stats); - -// 如果没有任何结果，返回一个空的成功状态 -if (results.length === 0) { - return [{ - json: { - message: '没有新数据需要处理', - total_processed: items.length, - status: 'completed' - } - }]; -} - -return results; \ No newline at end of file diff --git a/scripts/n8n_deduplication_fix.js b/scripts/n8n_deduplication_fix.js deleted file mode 100644 index b7832c7..0000000 --- a/scripts/n8n_deduplication_fix.js +++ /dev/null @@ -1,85 +0,0 @@ -const items = $input.all(); -const processedItems = []; - -// 改进的哈希函数 - 基于内容生成稳定的ID -function generateStableId(title, pubDate, content) { - const normalizedTitle = title.trim().toLowerCase(); - const contentHash = content ? content.substring(0, 100) : ''; - const dateStr = pubDate || ''; - - const combined = normalizedTitle + '|' + dateStr + '|' + contentHash; - - let hash = 0; - for (let i = 0; i < combined.length; i++) { - const char = combined.charCodeAt(i); - hash = ((hash << 5) - hash) + char; - hash = hash & hash; - } - return Math.abs(hash).toString(16); -} - -// 1. 从数据库查询已存在的文章ID和标题 -const existingArticles = new Set(); -try { - const existing = await mongoClient.db('taigong').collection('articles') - .find({}, { projection: { article_id: 1, title: 1, content_hash: 1 } }) - .toArray(); - - existing.forEach(article => { - existingArticles.add(article.article_id); - // 同时用标题做备用检查 - existingArticles.add(article.title); - }); - - console.log(`数据库中已有 ${existing.length} 篇文章`); -} catch (error) { - console.log('查询现有文章失败:', error); -} - -// 2. 处理新数据 -for (const item of items) { - const data = item.json; - - // 跳过无效数据 - if (!data.title) continue; - - // 生成稳定的文章ID - const stableId = generateStableId( - data.title, - data.isoDate || data.pubDate, - data['content:encodedSnippet'] || data.contentSnippet || '' - ); - - // 检查是否已存在（用ID和标题双重检查） - if (existingArticles.has(stableId) || existingArticles.has(data.title)) { - console.log('跳过重复文章:', data.title); - continue; - } - - // 生成内容哈希用于后续去重检查 - const contentHash = generateStableId( - data['content:encodedSnippet'] || data.contentSnippet || '', - '', - '' - ); - - const processedItem = { - article_id: stableId, // 使用稳定ID - title: data.title, - content: data['content:encodedSnippet'] || data.contentSnippet || '', - content_hash: contentHash, // 新增：内容哈希 - published_time: data.isoDate || data.pubDate || new Date().toISOString(), - source_url: data.link || '', // 新增：源链接 - processed: false, - created_at: new Date().toISOString(), - last_updated: new Date().toISOString() // 新增：更新时间 - }; - - processedItems.push({ json: processedItem }); - // 添加到已存在集合，避免本次执行内重复 - existingArticles.add(stableId); - existingArticles.add(data.title); -} - -console.log(`处理完成: 原始${items.length}条, 去重后${processedItems.length}条`); -return processedItems; \ No newline at end of file diff --git a/scripts/n8n_direct_insert.js b/scripts/n8n_direct_insert.js deleted file mode 100644 index db3bc03..0000000 --- a/scripts/n8n_direct_insert.js +++ /dev/null @@ -1,85 +0,0 @@ -const items = $input.all(); -const results = []; - -// 如果没有数据需要插入 -if (items.length === 0 || (items.length === 1 && items[0].json.status === 'no_new_data')) { - console.log('没有新数据需要插入'); - return items; -} - -console.log(`准备插入 ${items.length} 条新文章`); - -// 准备批量插入的数据 -const documentsToInsert = items.map(item => item.json); - -try { - // 批量插入，因为已经确保了唯一性，所以直接插入 - const result = await mongoClient.db('taigong').collection('articles').insertMany( - documentsToInsert, - { ordered: false } // 即使某条失败也继续插入其他的 - ); - - console.log(`✅ 成功插入 ${result.insertedCount} 条文章`); - - // 返回插入结果 - for (let i = 0; i < documentsToInsert.length; i++) { - const doc = documentsToInsert[i]; - const insertedId = result.insertedIds[i]; - - results.push({ - json: { - action: 'inserted', - sequence_id: doc.sequence_id, - article_id: doc.article_id, - title: doc.title, - mongodb_id: insertedId, - status: 'success' - } - }); - } - -} catch (error) { - console.error('❌ 批量插入失败:', error.message); - - // 如果批量插入失败，尝试逐条插入 - console.log('尝试逐条插入...'); - - for (const doc of documentsToInsert) { - try { - const result = await mongoClient.db('taigong').collection('articles').insertOne(doc); - - console.log(`✅ 单条插入成功: ${doc.article_id}`); - results.push({ - json: { - action: 'inserted', - sequence_id: doc.sequence_id, - article_id: doc.article_id, - title: doc.title, - mongodb_id: result.insertedId, - status: 'success' - } - }); - - } catch (singleError) { - console.error(`❌ 单条插入失败 ${doc.article_id}:`, singleError.message); - results.push({ - json: { - action: 'error', - sequence_id: doc.sequence_id, - article_id: doc.article_id, - title: doc.title, - error: singleError.message, - status: 'failed' - } - }); - } - } -} - -// 统计结果 -const successCount = results.filter(r => r.json.status === 'success').length; -const failCount = results.filter(r => r.json.status === 'failed').length; - -console.log(`插入完成: 成功 ${successCount} 条, 失败 ${failCount} 条`); - -return results; \ No newline at end of file diff --git a/scripts/n8n_minimal_news.js b/scripts/n8n_minimal_news.js deleted file mode 100644 index 9de8b97..0000000 --- a/scripts/n8n_minimal_news.js +++ /dev/null @@ -1,39 +0,0 @@ -const items = $input.all(); - -console.log(`原始数据: ${items.length} 条`); - -// 本批次内去重 -const seenTitles = new Set(); -const uniqueItems = []; - -// 生成起始ID（基于时间戳，确保每次运行都不同） -let nextId = Math.floor(Date.now() / 1000); - -for (const item of items) { - const data = item.json; - - // 跳过无效数据 - if (!data.title) continue; - - // 本批次内去重 - if (seenTitles.has(data.title)) { - console.log('⏭️ 本批次重复，跳过:', data.title); - continue; - } - - const newsItem = { - id: nextId, - title: data.title, - published_time: data.isoDate || data.pubDate || new Date().toISOString(), - source_url: data.link || '' - }; - - uniqueItems.push({ json: newsItem }); - seenTitles.add(data.title); - - console.log(`✅ ID ${nextId}: ${data.title}`); - nextId++; -} - -console.log(`本批次去重后: ${uniqueItems.length} 条`); -return uniqueItems; \ No newline at end of file diff --git a/scripts/n8n_safe_insert.js b/scripts/n8n_safe_insert.js deleted file mode 100644 index 02e8c98..0000000 --- a/scripts/n8n_safe_insert.js +++ /dev/null @@ -1,54 +0,0 @@ -// n8n MongoDB插入节点代码 -const items = $input.all(); -const results = []; - -for (const item of items) { - const data = item.json; - - try { - // 使用upsert操作，避免重复插入 - const result = await mongoClient.db('taigong').collection('articles').updateOne( - { - $or: [ - { article_id: data.article_id }, - { title: data.title } - ] - }, - { - $setOnInsert: { - article_id: data.article_id, - title: data.title, - content: data.content, - content_hash: data.content_hash, - published_time: data.published_time, - source_url: data.source_url, - processed: data.processed, - created_at: data.created_at - }, - $set: { - last_updated: new Date().toISOString() - } - }, - { upsert: true } - ); - - if (result.upsertedCount > 0) { - console.log('新增文章:', data.title); - results.push({ - json: { - action: 'inserted', - article_id: data.article_id, - title: data.title - } - }); - } else { - console.log('文章已存在，跳过:', data.title); - } - - } catch (error) { - console.error('插入文章失败:', data.title, error); - } -} - -console.log(`成功处理 ${results.length} 篇新文章`); -return results; \ No newline at end of file diff --git a/scripts/n8n_sequential_id_system.js b/scripts/n8n_sequential_id_system.js deleted file mode 100644 index 466ade0..0000000 --- a/scripts/n8n_sequential_id_system.js +++ /dev/null @@ -1,119 +0,0 @@ -const items = $input.all(); -const processedItems = []; - -// 获取当前最大流水号 -async function getCurrentMaxId() { - try { - const result = await mongoClient.db('taigong').collection('articles') - .findOne({}, { - sort: { sequence_id: -1 }, - projection: { sequence_id: 1 } - }); - - return result ? result.sequence_id : 0; - } catch (error) { - console.log('获取最大流水号失败，从1开始:', error.message); - return 0; - } -} - -// 获取已存在的文章标题集合（用于去重检查） -async function getExistingTitles() { - try { - const existing = await mongoClient.db('taigong').collection('articles') - .find({}, { projection: { title: 1 } }) - .toArray(); - - return new Set(existing.map(doc => doc.title)); - } catch (error) { - console.log('获取已存在标题失败:', error.message); - return new Set(); - } -} - -// 生成内容哈希（用于内容变化检测） -function generateContentHash(content) { - if (!content) return ''; - - let hash = 0; - const str = content.substring(0, 200); // 取前200字符 - for (let i = 0; i < str.length; i++) { - const char = str.charCodeAt(i); - hash = ((hash << 5) - hash) + char; - hash = hash & hash; - } - return Math.abs(hash).toString(16); -} - -console.log(`开始处理 ${items.length} 条RSS数据`); - -// 1. 获取当前最大流水号 -const currentMaxId = await getCurrentMaxId(); -console.log(`当前数据库最大流水号: ${currentMaxId}`); - -// 2. 获取已存在的文章标题 -const existingTitles = await getExistingTitles(); -console.log(`数据库中已有 ${existingTitles.size} 篇文章`); - -// 3. 处理新数据，分配流水号 -let nextSequenceId = currentMaxId + 1; -const seenTitlesInBatch = new Set(); // 本批次内去重 - -for (const item of items) { - const data = item.json; - - // 跳过无效数据 - if (!data.title) { - console.log('跳过无标题数据'); - continue; - } - - // 检查是否已存在（数据库 + 本批次） - if (existingTitles.has(data.title) || seenTitlesInBatch.has(data.title)) { - console.log('⏭️ 跳过重复文章:', data.title); - continue; - } - - // 分配新的流水号 - const sequenceId = nextSequenceId++; - - // 生成文章数据 - const articleData = { - sequence_id: sequenceId, // 主键：流水号 - article_id: `NEWS_${sequenceId.toString().padStart(8, '0')}`, // 格式化ID：NEWS_00000001 - title: data.title, - content: data['content:encodedSnippet'] || data.contentSnippet || '', - content_hash: generateContentHash(data['content:encodedSnippet'] || data.contentSnippet || ''), - published_time: data.isoDate || data.pubDate || new Date().toISOString(), - source_url: data.link || '', - rss_source: data.meta?.title || 'unknown', // RSS源名称 - processed: false, - created_at: new Date().toISOString(), - batch_id: Date.now().toString() // 批次ID，用于追踪 - }; - - processedItems.push({ json: articleData }); - seenTitlesInBatch.add(data.title); - - console.log(`✅ 分配流水号 ${sequenceId}: ${data.title}`); -} - -console.log(`流水号分配完成:`); -console.log(` 原始数据: ${items.length} 条`); -console.log(` 跳过重复: ${items.length - processedItems.length} 条`); -console.log(` 新增数据: ${processedItems.length} 条`); -console.log(` 流水号范围: ${currentMaxId + 1} - ${nextSequenceId - 1}`); - -// 如果没有新数据，返回空结果 -if (processedItems.length === 0) { - return [{ - json: { - message: '没有新数据需要处理', - current_max_id: currentMaxId, - total_articles_in_db: existingTitles.size, - status: 'no_new_data' - } - }]; -} - -return processedItems; \ No newline at end of file diff --git a/scripts/n8n_simple_dedup.js b/scripts/n8n_simple_dedup.js deleted file mode 100644 index 556456b..0000000 --- a/scripts/n8n_simple_dedup.js +++ /dev/null @@ -1,52 +0,0 @@ -const items = $input.all(); - -// 简单哈希函数 -function simpleHash(str) { - let hash = 0; - for (let i = 0; i < str.length; i++) { - const char = str.charCodeAt(i); - hash = ((hash << 5) - hash) + char; - hash = hash & hash; - } - return Math.abs(hash).toString(16); -} - -console.log(`原始数据: ${items.length} 条`); - -// 用标题去重 -const seenTitles = new Set(); -const uniqueItems = []; - -for (const item of items) { - const data = item.json; - - // 跳过无效数据 - if (!data.title) continue; - - // 本批次内去重 - if (seenTitles.has(data.title)) { - console.log('跳过重复:', data.title); - continue; - } - - // 生成稳定ID - const stableId = simpleHash(data.title + (data.isoDate || data.pubDate || '')); - - const processedItem = { - article_id: stableId, - title: data.title, - content: data['content:encodedSnippet'] || data.contentSnippet || '', - published_time: data.isoDate || data.pubDate || new Date().toISOString(), - source_url: data.link || '', - processed: false, - created_at: new Date().toISOString() - }; - - uniqueItems.push({ json: processedItem }); - seenTitles.add(data.title); - - console.log(`✅ 处理: ${data.title}`); -} - -console.log(`去重后: ${uniqueItems.length} 条`); -return uniqueItems; \ No newline at end of file diff --git a/scripts/n8n_universal_mongo.js b/scripts/n8n_universal_mongo.js deleted file mode 100644 index 317cbab..0000000 --- a/scripts/n8n_universal_mongo.js +++ /dev/null @@ -1,163 +0,0 @@ -const items = $input.all(); -const results = []; - -// 通用MongoDB连接获取函数 -function getMongoConnection() { - // 尝试不同的MongoDB连接变量名 - if (typeof mongoClient !== 'undefined') return mongoClient; - if (typeof mongo !== 'undefined') return mongo; - if (typeof db !== 'undefined') return db; - if (typeof $mongo !== 'undefined') return $mongo; - if (typeof client !== 'undefined') return client; - - throw new Error('找不到MongoDB连接对象，请检查n8n MongoDB节点配置'); -} - -// 改进的哈希函数 - 基于内容生成稳定的ID -function generateStableId(title, pubDate, content) { - const normalizedTitle = title.trim().toLowerCase(); - const contentHash = content ? content.substring(0, 100) : ''; - const dateStr = pubDate || ''; - - const combined = normalizedTitle + '|' + dateStr + '|' + contentHash; - - let hash = 0; - for (let i = 0; i < combined.length; i++) { - const char = combined.charCodeAt(i); - hash = ((hash << 5) - hash) + char; - hash = hash & hash; - } - return Math.abs(hash).toString(16); -} - -console.log(`开始处理 ${items.length} 条RSS数据`); - -// 获取MongoDB连接 -let mongoConnection; -try { - mongoConnection = getMongoConnection(); - console.log('✅ MongoDB连接获取成功'); -} catch (error) { - console.error('❌ MongoDB连接失败:', error.message); - return [{ - json: { - error: 'MongoDB连接失败', - message: error.message, - status: 'connection_failed' - } - }]; -} - -// 用于本次执行内去重 -const processedInThisRun = new Set(); - -// 处理每个RSS项目 -for (const item of items) { - const data = item.json; - - // 跳过无效数据 - if (!data.title) { - console.log('跳过无标题数据'); - continue; - } - - // 本次执行内去重检查 - if (processedInThisRun.has(data.title)) { - console.log('⏭️ 本次执行内重复，跳过:', data.title); - continue; - } - - // 生成稳定的文章ID - const stableId = generateStableId( - data.title, - data.isoDate || data.pubDate, - data['content:encodedSnippet'] || data.contentSnippet || '' - ); - - // 生成内容哈希 - const contentHash = generateStableId( - data['content:encodedSnippet'] || data.contentSnippet || '', - '', - '' - ); - - // 准备文章数据 - const articleData = { - article_id: stableId, - title: data.title, - content: data['content:encodedSnippet'] || data.contentSnippet || '', - content_hash: contentHash, - published_time: data.isoDate || data.pubDate || new Date().toISOString(), - source_url: data.link || '', - rss_source: data.meta?.title || 'unknown', - processed: false, - created_at: new Date().toISOString(), - last_updated: new Date().toISOString() - }; - - try { - // 检查数据库中是否已存在 - const existing = await mongoConnection.db('taigong').collection('articles').findOne({ - $or: [ - { article_id: stableId }, - { title: data.title } - ] - }); - - if (existing) { - console.log('⏭️ 数据库中已存在，跳过:', data.title); - continue; - } - - // 插入新文章 - const result = await mongoConnection.db('taigong').collection('articles').insertOne(articleData); - - console.log('✅ 新增文章:', data.title); - results.push({ - json: { - action: 'inserted', - article_id: stableId, - title: data.title, - mongodb_id: result.insertedId, - status: 'success' - } - }); - - // 添加到本次执行的去重集合 - processedInThisRun.add(data.title); - - } catch (error) { - console.error('❌ 处理文章失败:', data.title, error.message); - results.push({ - json: { - action: 'error', - title: data.title, - error: error.message, - status: 'failed' - } - }); - } -} - -console.log(`处理完成: 原始${items.length}条, 成功处理${results.length}条`); - -// 统计结果 -const stats = results.reduce((acc, item) => { - acc[item.json.action] = (acc[item.json.action] || 0) + 1; - return acc; -}, {}); - -console.log('处理统计:', stats); - -// 如果没有任何结果，返回一个空的成功状态 -if (results.length === 0) { - return [{ - json: { - message: '没有新数据需要处理', - total_processed: items.length, - status: 'completed' - } - }]; -} - -return results; \ No newline at end of file diff --git a/scripts/test_openrouter_api.py b/scripts/test_openrouter_api.py deleted file mode 100644 index 4f580a6..0000000 --- a/scripts/test_openrouter_api.py +++ /dev/null @@ -1,163 +0,0 @@ -#!/usr/bin/env python3 -""" -测试OpenRouter API连接 -重构版本：使用统一配置管理 -""" - -import requests -from typing import Dict, Any - -def test_openrouter_api() -> bool: - """ - 测试OpenRouter API连接 - - Returns: - 测试是否成功 - """ - # 使用统一配置管理 - try: - from config.doppler_config import get_openrouter_key - api_key = get_openrouter_key() - except ImportError: - # 如果配置模块不可用，使用环境变量 - import os - api_key = os.getenv('OPENROUTER_API_KEY_1') - except Exception as e: - print(f"❌ 无法获取API密钥: {e}") - return False - - if not api_key: - print("❌ 未找到OpenRouter API密钥") - print("请确保已配置 OPENROUTER_API_KEY_1 环境变量") - return False - - print(f"🔑 使用API密钥: {api_key[:20]}...") - - # 测试API调用 - url = "https://openrouter.ai/api/v1/chat/completions" - headers = { - "Authorization": f"Bearer {api_key}", - "HTTP-Referer": "https://github.com/ben/liurenchaxin", - "X-Title": "Jixia Academy Debate System", - "Content-Type": "application/json" - } - - data = { - "model": "openai/gpt-3.5-turbo", - "messages": [ - {"role": "user", "content": "你好，请简单回复一下测试连接"} - ], - "max_tokens": 50 - } - - try: - print("📡 正在测试API连接...") - response = requests.post(url, headers=headers, json=data, timeout=30) - print(f"📡 响应状态码: {response.status_code}") - - if response.status_code == 200: - result = response.json() - print("✅ OpenRouter API连接成功!") - if 'choices' in result and len(result['choices']) > 0: - content = result['choices'][0]['message']['content'] - print(f"📝 AI回复: {content}") - else: - print("📝 API响应格式异常，但连接成功") - return True - else: - print(f"❌ API调用失败: HTTP {response.status_code}") - print(f"错误详情: {response.text}") - return False - - except requests.exceptions.Timeout: - print("❌ 请求超时，请检查网络连接") - return False - except requests.exceptions.RequestException as e: - print(f"❌ 网络请求异常: {e}") - return False - except Exception as e: - print(f"❌ 未知异常: {e}") - return False - -def test_rapidapi_connection() -> bool: - """ - 测试RapidAPI连接 - - Returns: - 测试是否成功 - """ - try: - from config.doppler_config import get_rapidapi_key - api_key = get_rapidapi_key() - except ImportError: - import os - api_key = os.getenv('RAPIDAPI_KEY') - except Exception as e: - print(f"❌ 无法获取RapidAPI密钥: {e}") - return False - - if not api_key: - print("❌ 未找到RapidAPI密钥") - return False - - print(f"🔑 测试RapidAPI连接...") - - # 测试一个简单的API端点 - url = "https://yahoo-finance15.p.rapidapi.com/api/yahoo/qu/quote/AAPL" - headers = { - 'X-RapidAPI-Key': api_key, - 'X-RapidAPI-Host': 'yahoo-finance15.p.rapidapi.com' - } - - try: - response = requests.get(url, headers=headers, timeout=10) - if response.status_code == 200: - print("✅ RapidAPI连接成功!") - return True - else: - print(f"❌ RapidAPI连接失败: HTTP {response.status_code}") - return False - except Exception as e: - print(f"❌ RapidAPI连接异常: {e}") - return False - -def main(): - """主函数 - 运行所有API连接测试""" - print("🧪 API连接测试套件") - print("=" * 50) - - # 测试配置验证 - try: - from config.doppler_config import validate_config - print("\n🔧 验证配置...") - config_valid = validate_config() - except ImportError: - print("⚠️ 配置模块不可用，跳过配置验证") - config_valid = True - - # 测试OpenRouter API - print("\n🤖 测试OpenRouter API...") - openrouter_success = test_openrouter_api() - - # 测试RapidAPI - print("\n📊 测试RapidAPI...") - rapidapi_success = test_rapidapi_api() - - # 总结测试结果 - print("\n" + "=" * 50) - print("📋 测试结果总结:") - print(f" 配置验证: {'✅ 通过' if config_valid else '❌ 失败'}") - print(f" OpenRouter API: {'✅ 通过' if openrouter_success else '❌ 失败'}") - print(f" RapidAPI: {'✅ 通过' if rapidapi_success else '❌ 失败'}") - - all_passed = config_valid and openrouter_success and rapidapi_success - if all_passed: - print("\n🎉 所有API连接测试通过！系统已准备就绪。") - else: - print("\n⚠️ 部分测试失败，请检查配置和网络连接。") - - return all_passed - -if __name__ == "__main__": - success = main() - exit(0 if success else 1) \ No newline at end of file diff --git a/scripts/test_rapidapi_inventory.py b/scripts/test_rapidapi_inventory.py deleted file mode 100644 index 75414bf..0000000 --- a/scripts/test_rapidapi_inventory.py +++ /dev/null @@ -1,297 +0,0 @@ -#!/usr/bin/env python3 -""" -RapidAPI库存测试脚本 -自动测试所有订阅的API服务，生成可用性报告 -""" - -import requests -import json -import time -from datetime import datetime -from typing import Dict, List, Any -import os - -class RapidAPITester: - """RapidAPI测试器""" - - def __init__(self): - """初始化测试器""" - # 从环境变量获取API密钥 - self.api_key = os.getenv('RAPIDAPI_KEY') - if not self.api_key: - raise ValueError("RAPIDAPI_KEY环境变量未设置") - - # API配置 - 基于永动机引擎的配置 - self.api_configs = { - 'alpha_vantage': 'alpha-vantage.p.rapidapi.com', - 'yahoo_finance_1': 'yahoo-finance15.p.rapidapi.com', - 'yh_finance_complete': 'yh-finance.p.rapidapi.com', - 'yahoo_finance_api_data': 'yahoo-finance-api1.p.rapidapi.com', - 'yahoo_finance_realtime': 'yahoo-finance-low-latency.p.rapidapi.com', - 'yh_finance': 'yh-finance-complete.p.rapidapi.com', - 'yahoo_finance_basic': 'yahoo-finance127.p.rapidapi.com', - 'seeking_alpha': 'seeking-alpha.p.rapidapi.com', - 'webull': 'webull.p.rapidapi.com', - 'morning_star': 'morningstar1.p.rapidapi.com', - 'tradingview': 'tradingview-ta.p.rapidapi.com', - 'investing_com': 'investing-cryptocurrency-markets.p.rapidapi.com', - 'finance_api': 'real-time-finance-data.p.rapidapi.com', - 'ms_finance': 'ms-finance.p.rapidapi.com', - 'sec_filings': 'sec-filings.p.rapidapi.com', - 'exchangerate_api': 'exchangerate-api.p.rapidapi.com', - 'crypto_news': 'cryptocurrency-news2.p.rapidapi.com' - } - - # 测试端点配置 - self.test_endpoints = { - 'alpha_vantage': '/query?function=GLOBAL_QUOTE&symbol=AAPL', - 'yahoo_finance_1': '/api/yahoo/qu/quote/AAPL', - 'yh_finance_complete': '/stock/v2/get-summary?symbol=AAPL', - 'yahoo_finance_api_data': '/v8/finance/chart/AAPL', - 'yahoo_finance_realtime': '/stock/v2/get-summary?symbol=AAPL', - 'yh_finance': '/stock/v2/get-summary?symbol=AAPL', - 'yahoo_finance_basic': '/api/yahoo/qu/quote/AAPL', - 'seeking_alpha': '/symbols/get-profile?symbols=AAPL', - 'webull': '/stock/search?keyword=AAPL', - 'morning_star': '/market/v2/get-movers?performanceId=0P0000OQN8', - 'tradingview': '/get-analysis?symbol=AAPL&screener=america&exchange=NASDAQ', - 'investing_com': '/coins/get-overview', - 'finance_api': '/stock-price?symbol=AAPL', - 'ms_finance': '/stock/v2/get-summary?symbol=AAPL', - 'sec_filings': '/search?query=AAPL', - 'exchangerate_api': '/latest?base=USD', - 'crypto_news': '/v1/cryptonews' - } - - self.results = {} - - def test_api(self, api_name: str) -> Dict[str, Any]: - """ - 测试单个API - - Args: - api_name: API名称 - - Returns: - 测试结果 - """ - if api_name not in self.api_configs: - return { - 'success': False, - 'error': 'API not configured', - 'status_code': None, - 'response_time': 0 - } - - host = self.api_configs[api_name] - endpoint = self.test_endpoints.get(api_name, '/') - - headers = { - 'X-RapidAPI-Key': self.api_key, - 'X-RapidAPI-Host': host, - 'Content-Type': 'application/json' - } - - url = f"https://{host}{endpoint}" - - print(f"🧪 测试 {api_name} ({host})") - print(f" URL: {url}") - - start_time = time.time() - - try: - response = requests.get(url, headers=headers, timeout=10) - response_time = time.time() - start_time - - result = { - 'success': response.status_code == 200, - 'status_code': response.status_code, - 'response_time': round(response_time, 2), - 'response_size': len(response.text), - 'error': None if response.status_code == 200 else response.text[:200] - } - - if response.status_code == 200: - print(f" ✅ 成功 - {response_time:.2f}s - {len(response.text)} bytes") - # 尝试解析JSON - try: - data = response.json() - result['has_data'] = bool(data) - result['data_keys'] = list(data.keys()) if isinstance(data, dict) else [] - except: - result['has_data'] = False - result['data_keys'] = [] - else: - print(f" ❌ 失败 - HTTP {response.status_code}") - print(f" 错误: {response.text[:100]}...") - - return result - - except requests.exceptions.Timeout: - print(f" ⏰ 超时") - return { - 'success': False, - 'error': 'Request timeout', - 'status_code': None, - 'response_time': 10.0 - } - except requests.exceptions.RequestException as e: - print(f" ❌ 请求异常: {str(e)}") - return { - 'success': False, - 'error': f'Request error: {str(e)}', - 'status_code': None, - 'response_time': time.time() - start_time - } - except Exception as e: - print(f" ❌ 未知异常: {str(e)}") - return { - 'success': False, - 'error': f'Unexpected error: {str(e)}', - 'status_code': None, - 'response_time': time.time() - start_time - } - - def test_all_apis(self) -> Dict[str, Any]: - """测试所有API""" - print("🚀 开始测试所有RapidAPI服务") - print("=" * 60) - - for api_name in self.api_configs.keys(): - result = self.test_api(api_name) - self.results[api_name] = result - time.sleep(1) # 避免请求过快 - print() - - return self.results - - def generate_report(self) -> str: - """生成测试报告""" - if not self.results: - return "没有测试结果" - - # 统计 - total_apis = len(self.results) - successful_apis = len([r for r in self.results.values() if r['success']]) - failed_apis = total_apis - successful_apis - - # 按状态分类 - success_list = [] - failed_list = [] - - for api_name, result in self.results.items(): - if result['success']: - success_list.append({ - 'name': api_name, - 'host': self.api_configs[api_name], - 'response_time': result['response_time'], - 'data_keys': result.get('data_keys', []) - }) - else: - failed_list.append({ - 'name': api_name, - 'host': self.api_configs[api_name], - 'error': result['error'], - 'status_code': result['status_code'] - }) - - # 生成报告 - report = f"""# RapidAPI 测试报告 - -## 📊 测试概览 - -- **测试时间**: {datetime.now().strftime('%Y-%m-%d %H:%M:%S')} -- **总API数**: {total_apis} -- **成功数**: {successful_apis} ({successful_apis/total_apis*100:.1f}%) -- **失败数**: {failed_apis} ({failed_apis/total_apis*100:.1f}%) - -## ✅ 可用的API ({len(success_list)}个) - -""" - - for api in sorted(success_list, key=lambda x: x['response_time']): - report += f"### {api['name']}\n" - report += f"- **主机**: `{api['host']}`\n" - report += f"- **响应时间**: {api['response_time']}s\n" - if api['data_keys']: - report += f"- **数据字段**: {', '.join(api['data_keys'][:5])}\n" - report += "\n" - - report += f"## ❌ 失败的API ({len(failed_list)}个)\n\n" - - for api in failed_list: - report += f"### {api['name']}\n" - report += f"- **主机**: `{api['host']}`\n" - report += f"- **状态码**: {api['status_code']}\n" - report += f"- **错误**: {api['error'][:100] if api['error'] else 'Unknown'}...\n" - report += "\n" - - # 建议 - report += """## 🔧 优化建议 - -### 立即可用的API -""" - - fast_apis = [api for api in success_list if api['response_time'] < 2.0] - if fast_apis: - report += "以下API响应快速，建议优先使用：\n" - for api in fast_apis: - report += f"- **{api['name']}**: {api['response_time']}s\n" - - report += """ -### 需要修复的API -""" - - if failed_list: - report += "以下API需要检查端点配置或权限：\n" - for api in failed_list[:5]: # 只显示前5个 - report += f"- **{api['name']}**: {api['error'][:50] if api['error'] else 'Unknown error'}...\n" - - return report - - def save_report(self, filename: str = None): - """保存报告到文件""" - if not filename: - timestamp = datetime.now().strftime('%Y%m%d_%H%M%S') - filename = f"docs/rapidapi/test_report_{timestamp}.md" - - report = self.generate_report() - - with open(filename, 'w', encoding='utf-8') as f: - f.write(report) - - print(f"📄 报告已保存到: {filename}") - return filename - -def main(): - """主函数""" - print("🧪 RapidAPI库存测试工具") - print("=" * 40) - - try: - tester = RapidAPITester() - - # 测试所有API - results = tester.test_all_apis() - - # 生成并显示报告 - print("\n" + "=" * 60) - print("📊 测试完成，生成报告...") - - report = tester.generate_report() - print(report) - - # 保存报告 - filename = tester.save_report() - - # 更新库存文档 - print(f"\n💡 建议更新 docs/rapidapi/api_inventory.md") - print(f"📁 详细报告: {filename}") - - except Exception as e: - print(f"❌ 测试失败: {e}") - import traceback - traceback.print_exc() - -if __name__ == "__main__": - main() \ No newline at end of file diff --git a/shushu-demo-results.md b/shushu-demo-results.md new file mode 100644 index 0000000..0878b2e --- /dev/null +++ b/shushu-demo-results.md @@ -0,0 +1,152 @@ +# 术数书 Hyperdrive + NeonDB 查询系统演示结果 + +## 系统概述 + +我们成功部署了一个基于 Cloudflare Hyperdrive + NeonDB 的术数书查询系统，通过高性能的边缘计算和数据库连接池优化，实现了对古代术数典籍的快速查询和检索。 + +## 部署信息 + +- **Worker URL**: https://hyperdrive.seekkey.tech/ +- **Hyperdrive ID**: ef43924d89064cddabfaccf06aadfab6 +- **数据库**: NeonDB PostgreSQL +- **连接池**: 已启用 +- **边缘缓存**: 全球分布 + +## 可用 API 端点 + +### 1. 基础端点 +- `GET /` - 系统信息和端点列表 +- `GET /test-connection` - 测试数据库连接 +- `GET /test-query` - 测试数据库查询 + +### 2. 术数书查询端点 +- `GET /query-tables` - 查询数据库表结构 +- `GET /query-shushu?limit=N` - 查询术数书内容 +- `GET /search-shushu?q=keyword&limit=N` - 搜索术数书内容 +- `GET /shushu-stats` - 获取术数书统计信息 + +## 数据库结构 + +通过 `/query-tables` 端点发现的表结构： + +```json +{ + "status": "success", + "message": "Tables retrieved successfully", + "tables": [ + { + "table_name": "books", + "table_schema": "public" + }, + { + "table_name": "hyperdrive_test", + "table_schema": "public" + }, + { + "table_name": "playing_with_neon", + "table_schema": "public" + } + ] +} +``` + +## 术数书内容示例 + +通过 `/query-shushu?limit=3` 成功获取的术数书内容： + +### 书籍信息 +- **ID**: 1 +- **标题**: 《神相全编》 +- **作者**: 袁珙 +- **类别**: 相术 +- **子类别**: 面相手相 +- **总字数**: 33,897 字 +- **创建时间**: 2025-07-17T15:48:55.563Z + +### 内容片段 + +``` +诈。口尖唇薄者多妄。冷笑无情多诈。偷视不正多诈。视上顾下多诈。 +妄说语言如太急者多诈。牙齿疏者多诈。又曰鼻尖毫出、眼细视低， +口角高低，步履纵横，行步不匀，脚走高低多诈。 + +宽大 +升斗满，部位中正，印堂开阔，诸部圆满，鼻窍微露。阴德眼上下堂 +有黄气，卧蚕出见，印堂黄气，精舍黄气。带令地角朝天、耳有轮廓 +朝水，口有棱角。眼带桃花眉如线。又如新月久视，意气可人。 + +贪食格 +鼻如鹰嘴者多贪，心狡。眼红者多贪，心毒。眉卓者多贪。嘴尖者多贪。 +鼻勾者多贪。 + +劳碌格 +眼长多劳碌。骨粗多劳碌。面如马面驴唇劳碌。眉重气弱者劳碌。 +鱼尾纹多者劳碌。 +``` + +## 系统特点 + +### 1. 高性能优化 +- **Hyperdrive 连接池**: 减少数据库连接开销 +- **边缘缓存**: 全球分布式缓存，降低延迟 +- **智能路由**: 自动选择最近的数据中心 + +### 2. 成本优化 +- **连接复用**: 大幅减少 NeonDB 的连接数消耗 +- **查询缓存**: 减少重复查询的数据库负载 +- **按需扩展**: 根据访问量自动调整资源 + +### 3. 功能特性 +- **多表查询**: 自动检测和查询可能的术数书表 +- **全文搜索**: 支持关键词搜索术数书内容 +- **统计分析**: 提供数据库使用统计信息 +- **RESTful API**: 标准化的 API 接口 + +## 与 AutoRAG 对比的优势 + +### 1. 数据访问速度 +- **Hyperdrive**: 全球边缘缓存，毫秒级响应 +- **AutoRAG**: 依赖本地或远程向量数据库，可能有网络延迟 + +### 2. 数据一致性 +- **Hyperdrive**: 直接查询源数据库，保证数据实时性 +- **AutoRAG**: 向量化数据可能存在更新延迟 + +### 3. 查询精确性 +- **Hyperdrive**: SQL 精确查询，支持复杂条件 +- **AutoRAG**: 语义相似性查询，可能存在误差 + +### 4. 成本效益 +- **Hyperdrive**: 连接池优化，降低数据库成本 +- **AutoRAG**: 需要额外的向量数据库和计算资源 + +## 使用场景 + +### 1. 学术研究 +- 快速检索古代术数典籍 +- 支持精确的文本查询 +- 提供完整的原文内容 + +### 2. 应用开发 +- 为术数应用提供数据 API +- 支持多种查询方式 +- 高并发访问支持 + +### 3. 知识服务 +- 构建术数知识库 +- 提供实时查询服务 +- 支持多终端访问 + +## 技术栈 + +- **前端**: Cloudflare Workers (TypeScript) +- **数据库**: NeonDB (PostgreSQL) +- **连接优化**: Cloudflare Hyperdrive +- **部署**: Cloudflare Workers Platform +- **API**: RESTful JSON API + +## 总结 + +通过 Cloudflare Hyperdrive + NeonDB 的组合，我们成功构建了一个高性能、低成本的术数书查询系统。该系统不仅提供了快速的数据访问能力，还通过智能缓存和连接池优化，在 NeonDB 免费配额下支持了更大的访问量。 + +相比传统的 AutoRAG 方案，我们的系统在数据访问速度、查询精确性和成本控制方面都有显著优势，为术数典籍的数字化应用提供了一个理想的技术解决方案。 \ No newline at end of file diff --git a/src/advanced-example.ts b/src/advanced-example.ts new file mode 100644 index 0000000..7cde6bc --- /dev/null +++ b/src/advanced-example.ts @@ -0,0 +1,340 @@ +// 高级 Hyperdrive 使用示例 - 完整的 CRUD API +// 这个示例展示了如何构建一个生产级别的 API 服务 + +export interface Env { + HYPERDRIVE: Hyperdrive; + API_SECRET?: string; +} + +interface User { + id?: number; + name: string; + email: string; + created_at?: string; + updated_at?: string; +} + +interface ApiResponse { + status: 'success' | 'error'; + data?: T; + message?: string; + meta?: { + total?: number; + page?: number; + limit?: number; + }; +} + +// CORS 配置 +const corsHeaders = { + 'Access-Control-Allow-Origin': '*', + 'Access-Control-Allow-Methods': 'GET, POST, PUT, DELETE, OPTIONS', + 'Access-Control-Allow-Headers': 'Content-Type, Authorization, X-API-Key', +}; + +// 响应工具函数 +function jsonResponse(data: ApiResponse, status = 200): Response { + return new Response(JSON.stringify(data, null, 2), { + status, + headers: { + 'Content-Type': 'application/json', + ...corsHeaders, + }, + }); +} + +// 错误响应 +function errorResponse(message: string, status = 500): Response { + return jsonResponse({ status: 'error', message }, status); +} + +// 输入验证 +function validateUser(data: any): { valid: boolean; errors: string[] } { + const errors: string[] = []; + + if (!data.name || typeof data.name !== 'string' || data.name.trim().length < 2) { + errors.push('Name must be at least 2 characters'); + } + + if (!data.email || typeof data.email !== 'string' || !data.email.includes('@')) { + errors.push('Valid email is required'); + } + + return { valid: errors.length === 0, errors }; +} + +// API 密钥验证 +function validateApiKey(request: Request, env: Env): boolean { + if (!env.API_SECRET) return true; // 如果没有设置密钥，跳过验证 + + const apiKey = request.headers.get('X-API-Key') || request.headers.get('Authorization')?.replace('Bearer ', ''); + return apiKey === env.API_SECRET; +} + +// 数据库连接工具 +async function withDatabase(env: Env, operation: (client: any) => Promise): Promise { + const { Client } = await import('pg'); + const client = new Client({ connectionString: env.HYPERDRIVE.connectionString }); + + try { + await client.connect(); + return await operation(client); + } finally { + await client.end(); + } +} + +// 用户 CRUD 操作 +class UserService { + static async getUsers(env: Env, page = 1, limit = 10, search?: string): Promise<{ users: User[]; total: number }> { + return withDatabase(env, async (client) => { + let query = 'SELECT id, name, email, created_at, updated_at FROM users'; + let countQuery = 'SELECT COUNT(*) FROM users'; + const params: any[] = []; + + if (search) { + query += ' WHERE name ILIKE $1 OR email ILIKE $1'; + countQuery += ' WHERE name ILIKE $1 OR email ILIKE $1'; + params.push(`%${search}%`); + } + + query += ` ORDER BY created_at DESC LIMIT $${params.length + 1} OFFSET $${params.length + 2}`; + params.push(limit, (page - 1) * limit); + + const [usersResult, countResult] = await Promise.all([ + client.query(query, params), + client.query(countQuery, search ? [`%${search}%`] : []) + ]); + + return { + users: usersResult.rows, + total: parseInt(countResult.rows[0].count) + }; + }); + } + + static async getUserById(env: Env, id: number): Promise { + return withDatabase(env, async (client) => { + const result = await client.query( + 'SELECT id, name, email, created_at, updated_at FROM users WHERE id = $1', + [id] + ); + return result.rows[0] || null; + }); + } + + static async createUser(env: Env, userData: Omit): Promise { + return withDatabase(env, async (client) => { + const result = await client.query( + 'INSERT INTO users (name, email, created_at, updated_at) VALUES ($1, $2, NOW(), NOW()) RETURNING id, name, email, created_at, updated_at', + [userData.name.trim(), userData.email.toLowerCase().trim()] + ); + return result.rows[0]; + }); + } + + static async updateUser(env: Env, id: number, userData: Partial>): Promise { + return withDatabase(env, async (client) => { + const setParts: string[] = []; + const params: any[] = []; + let paramIndex = 1; + + if (userData.name !== undefined) { + setParts.push(`name = $${paramIndex++}`); + params.push(userData.name.trim()); + } + + if (userData.email !== undefined) { + setParts.push(`email = $${paramIndex++}`); + params.push(userData.email.toLowerCase().trim()); + } + + if (setParts.length === 0) { + throw new Error('No fields to update'); + } + + setParts.push(`updated_at = NOW()`); + params.push(id); + + const result = await client.query( + `UPDATE users SET ${setParts.join(', ')} WHERE id = $${paramIndex} RETURNING id, name, email, created_at, updated_at`, + params + ); + + return result.rows[0] || null; + }); + } + + static async deleteUser(env: Env, id: number): Promise { + return withDatabase(env, async (client) => { + const result = await client.query('DELETE FROM users WHERE id = $1', [id]); + return result.rowCount > 0; + }); + } + + static async initializeDatabase(env: Env): Promise { + return withDatabase(env, async (client) => { + await client.query(` + CREATE TABLE IF NOT EXISTS users ( + id SERIAL PRIMARY KEY, + name VARCHAR(255) NOT NULL, + email VARCHAR(255) UNIQUE NOT NULL, + created_at TIMESTAMP WITH TIME ZONE DEFAULT NOW(), + updated_at TIMESTAMP WITH TIME ZONE DEFAULT NOW() + ) + `); + + // 创建索引 + await client.query('CREATE INDEX IF NOT EXISTS idx_users_email ON users(email)'); + await client.query('CREATE INDEX IF NOT EXISTS idx_users_created_at ON users(created_at)'); + }); + } +} + +// 路由处理 +export default { + async fetch(request: Request, env: Env, ctx: ExecutionContext): Promise { + const url = new URL(request.url); + const path = url.pathname; + const method = request.method; + + // 处理 CORS 预检请求 + if (method === 'OPTIONS') { + return new Response(null, { headers: corsHeaders }); + } + + // API 密钥验证 + if (!validateApiKey(request, env)) { + return errorResponse('Unauthorized', 401); + } + + try { + // 路由匹配 + if (path === '/init' && method === 'POST') { + await UserService.initializeDatabase(env); + return jsonResponse({ status: 'success', message: 'Database initialized' }); + } + + if (path === '/users' && method === 'GET') { + const page = parseInt(url.searchParams.get('page') || '1'); + const limit = Math.min(parseInt(url.searchParams.get('limit') || '10'), 100); + const search = url.searchParams.get('search') || undefined; + + const { users, total } = await UserService.getUsers(env, page, limit, search); + + return jsonResponse({ + status: 'success', + data: users, + meta: { + total, + page, + limit, + } + }); + } + + if (path.match(/^\/users\/\d+$/) && method === 'GET') { + const id = parseInt(path.split('/')[2]); + const user = await UserService.getUserById(env, id); + + if (!user) { + return errorResponse('User not found', 404); + } + + return jsonResponse({ status: 'success', data: user }); + } + + if (path === '/users' && method === 'POST') { + const body = await request.json() as any; + const validation = validateUser(body); + + if (!validation.valid) { + return errorResponse(`Validation failed: ${validation.errors.join(', ')}`, 400); + } + + const user = await UserService.createUser(env, body as Omit); + return jsonResponse({ status: 'success', data: user, message: 'User created successfully' }, 201); + } + + if (path.match(/^\/users\/\d+$/) && method === 'PUT') { + const id = parseInt(path.split('/')[2]); + const body = await request.json() as any; + + // 部分验证（只验证提供的字段） + if (body.name !== undefined || body.email !== undefined) { + const validation = validateUser({ name: body.name || 'valid', email: body.email || 'valid@email.com' }); + if (!validation.valid) { + return errorResponse(`Validation failed: ${validation.errors.join(', ')}`, 400); + } + } + + const user = await UserService.updateUser(env, id, body as Partial>); + + if (!user) { + return errorResponse('User not found', 404); + } + + return jsonResponse({ status: 'success', data: user, message: 'User updated successfully' }); + } + + if (path.match(/^\/users\/\d+$/) && method === 'DELETE') { + const id = parseInt(path.split('/')[2]); + const deleted = await UserService.deleteUser(env, id); + + if (!deleted) { + return errorResponse('User not found', 404); + } + + return jsonResponse({ status: 'success', message: 'User deleted successfully' }); + } + + // 健康检查 + if (path === '/health') { + return jsonResponse({ + status: 'success', + data: { + service: 'hyperdrive-api', + timestamp: new Date().toISOString(), + version: '1.0.0' + } + }); + } + + // API 文档 + if (path === '/docs') { + const docs = { + endpoints: { + 'POST /init': 'Initialize database tables', + 'GET /users': 'List users (supports ?page, ?limit, ?search)', + 'GET /users/:id': 'Get user by ID', + 'POST /users': 'Create new user', + 'PUT /users/:id': 'Update user', + 'DELETE /users/:id': 'Delete user', + 'GET /health': 'Health check', + 'GET /docs': 'API documentation' + }, + authentication: 'Include X-API-Key header or Authorization: Bearer ', + examples: { + createUser: { + method: 'POST', + url: '/users', + body: { name: 'John Doe', email: 'john@example.com' } + }, + listUsers: { + method: 'GET', + url: '/users?page=1&limit=10&search=john' + } + } + }; + + return jsonResponse({ status: 'success', data: docs }); + } + + return errorResponse('Not found', 404); + + } catch (error) { + console.error('API Error:', error); + return errorResponse('Internal server error', 500); + } + }, +}; \ No newline at end of file diff --git a/src/index.ts b/src/index.ts new file mode 100644 index 0000000..6d5e7a4 --- /dev/null +++ b/src/index.ts @@ -0,0 +1,382 @@ +/// + +export interface Env { + HYPERDRIVE: Hyperdrive; +} + +export default { + async fetch(request: Request, env: Env, ctx: ExecutionContext): Promise { + try { + // Test Hyperdrive connection to NeonDB + const { pathname } = new URL(request.url); + + if (pathname === '/test-connection') { + return await testConnection(env); + } + + if (pathname === '/test-query') { + return await testQuery(env); + } + + if (pathname === '/query-tables') { + return await queryTables(env); + } + + if (pathname === '/query-shushu') { + const url = new URL(request.url); + const limit = parseInt(url.searchParams.get('limit') || '10'); + return await queryShushuBook(env, limit); + } + + if (pathname === '/search-shushu') { + const url = new URL(request.url); + const keyword = url.searchParams.get('q') || ''; + const limit = parseInt(url.searchParams.get('limit') || '5'); + return await searchShushuBook(env, keyword, limit); + } + + if (pathname === '/shushu-stats') { + return await getShushuStats(env); + } + + return new Response('Hyperdrive NeonDB Test Worker\n\nEndpoints:\n- /test-connection - Test database connection\n- /test-query - Test database query\n- /query-tables - List all tables\n- /query-shushu?limit=N - Query shushu book content\n- /search-shushu?q=keyword&limit=N - Search shushu book\n- /shushu-stats - Get shushu book statistics', { + headers: { 'Content-Type': 'text/plain' } + }); + } catch (error) { + return new Response(`Error: ${error.message}`, { + status: 500, + headers: { 'Content-Type': 'text/plain' } + }); + } + }, +}; + +async function testConnection(env: Env): Promise { + try { + // Get connection string from Hyperdrive + const connectionString = env.HYPERDRIVE.connectionString; + + // Create a simple connection test + const { Client } = await import('pg'); + const client = new Client({ connectionString }); + + await client.connect(); + + // Test basic query + const result = await client.query('SELECT NOW() as current_time, version() as pg_version'); + + await client.end(); + + return new Response(JSON.stringify({ + status: 'success', + message: 'Successfully connected to NeonDB via Hyperdrive', + data: result.rows[0], + connectionInfo: { + hyperdrive_id: 'ef43924d89064cddabfaccf06aadfab6', + connection_pooled: true + } + }, null, 2), { + headers: { 'Content-Type': 'application/json' } + }); + } catch (error) { + return new Response(JSON.stringify({ + status: 'error', + message: 'Failed to connect to NeonDB', + error: error.message + }, null, 2), { + status: 500, + headers: { 'Content-Type': 'application/json' } + }); + } +} + +// 查询数据库表结构 +async function queryTables(env: Env): Promise { + try { + const { Client } = await import('pg'); + const client = new Client({ + connectionString: env.HYPERDRIVE.connectionString + }); + + await client.connect(); + + // 查询所有表 + const result = await client.query(` + SELECT table_name, table_schema + FROM information_schema.tables + WHERE table_schema NOT IN ('information_schema', 'pg_catalog') + ORDER BY table_schema, table_name + `); + + await client.end(); + + return new Response(JSON.stringify({ + status: 'success', + message: 'Tables retrieved successfully', + tables: result.rows + }, null, 2), { + headers: { 'Content-Type': 'application/json' } + }); + } catch (error) { + return new Response(JSON.stringify({ + status: 'error', + message: 'Failed to query tables', + error: error.message + }, null, 2), { + status: 500, + headers: { 'Content-Type': 'application/json' } + }); + } +} + +// 查询术数书内容 +async function queryShushuBook(env: Env, limit: number = 10): Promise { + try { + const { Client } = await import('pg'); + const client = new Client({ + connectionString: env.HYPERDRIVE.connectionString + }); + + await client.connect(); + + // 尝试查询可能的术数书表名 + const tableNames = ['shushu', 'shushu_book', 'books', 'articles', 'content', 'documents']; + let result: any = null; + let tableName: string | null = null; + + for (const name of tableNames) { + try { + const testResult = await client.query(`SELECT * FROM ${name} LIMIT 1`); + if (testResult.rows.length > 0) { + tableName = name; + result = await client.query(`SELECT * FROM ${name} ORDER BY id DESC LIMIT $1`, [limit]); + break; + } + } catch (e) { + // 表不存在，继续尝试下一个 + continue; + } + } + + await client.end(); + + if (!result) { + return new Response(JSON.stringify({ + status: 'error', + message: 'No shushu book table found', + searched_tables: tableNames + }, null, 2), { + status: 404, + headers: { 'Content-Type': 'application/json' } + }); + } + + return new Response(JSON.stringify({ + status: 'success', + message: 'Shushu book content retrieved successfully', + table_name: tableName, + count: result.rows.length, + data: result.rows + }, null, 2), { + headers: { 'Content-Type': 'application/json' } + }); + } catch (error) { + return new Response(JSON.stringify({ + status: 'error', + message: 'Failed to query shushu book', + error: error.message + }, null, 2), { + status: 500, + headers: { 'Content-Type': 'application/json' } + }); + } +} + +// 搜索术数书内容 +async function searchShushuBook(env: Env, keyword: string, limit: number = 5): Promise { + try { + if (!keyword) { + return new Response(JSON.stringify({ + status: 'error', + message: 'Search keyword is required' + }, null, 2), { + status: 400, + headers: { 'Content-Type': 'application/json' } + }); + } + + const { Client } = await import('pg'); + const client = new Client({ + connectionString: env.HYPERDRIVE.connectionString + }); + + await client.connect(); + + // 尝试在不同的表和字段中搜索 + const searchQueries = [ + { table: 'shushu', fields: ['title', 'content', 'description'] }, + { table: 'shushu_book', fields: ['title', 'content', 'text'] }, + { table: 'books', fields: ['title', 'content', 'description'] }, + { table: 'articles', fields: ['title', 'content', 'body'] }, + { table: 'content', fields: ['title', 'text', 'content'] }, + { table: 'documents', fields: ['title', 'content', 'text'] } + ]; + + let results: any[] = []; + let searchedTables: string[] = []; + + for (const { table, fields } of searchQueries) { + try { + // 构建搜索条件 + const conditions = fields.map(field => `${field} ILIKE $1`).join(' OR '); + const query = `SELECT * FROM ${table} WHERE ${conditions} LIMIT $2`; + + const result = await client.query(query, [`%${keyword}%`, limit]); + + if (result.rows.length > 0) { + results.push({ + table_name: table, + count: result.rows.length, + data: result.rows + }); + } + + searchedTables.push(table); + } catch (e) { + // 表或字段不存在，继续搜索 + continue; + } + } + + await client.end(); + + return new Response(JSON.stringify({ + status: 'success', + message: `Search completed for keyword: ${keyword}`, + keyword: keyword, + searched_tables: searchedTables, + results: results, + total_matches: results.reduce((sum, r) => sum + r.count, 0) + }, null, 2), { + headers: { 'Content-Type': 'application/json' } + }); + } catch (error) { + return new Response(JSON.stringify({ + status: 'error', + message: 'Search failed', + error: error.message + }, null, 2), { + status: 500, + headers: { 'Content-Type': 'application/json' } + }); + } +} + +// 获取术数书统计信息 +async function getShushuStats(env: Env): Promise { + try { + const { Client } = await import('pg'); + const client = new Client({ + connectionString: env.HYPERDRIVE.connectionString + }); + + await client.connect(); + + const tableNames = ['shushu', 'shushu_book', 'books', 'articles', 'content', 'documents']; + let stats: any[] = []; + + for (const tableName of tableNames) { + try { + const countResult = await client.query(`SELECT COUNT(*) as count FROM ${tableName}`); + const sampleResult = await client.query(`SELECT * FROM ${tableName} LIMIT 1`); + + stats.push({ + table_name: tableName, + record_count: parseInt(countResult.rows[0].count), + sample_columns: sampleResult.rows.length > 0 ? Object.keys(sampleResult.rows[0]) : [], + exists: true + }); + } catch (e) { + stats.push({ + table_name: tableName, + exists: false + }); + } + } + + await client.end(); + + return new Response(JSON.stringify({ + status: 'success', + message: 'Statistics retrieved successfully', + stats: stats, + existing_tables: stats.filter(s => s.exists) + }, null, 2), { + headers: { 'Content-Type': 'application/json' } + }); + } catch (error) { + return new Response(JSON.stringify({ + status: 'error', + message: 'Failed to get statistics', + error: error.message + }, null, 2), { + status: 500, + headers: { 'Content-Type': 'application/json' } + }); + } +} + +async function testQuery(env: Env): Promise { + try { + const { Client } = await import('pg'); + const client = new Client({ + connectionString: env.HYPERDRIVE.connectionString + }); + + await client.connect(); + + // Create a test table if it doesn't exist + await client.query(` + CREATE TABLE IF NOT EXISTS hyperdrive_test ( + id SERIAL PRIMARY KEY, + message TEXT, + created_at TIMESTAMP DEFAULT NOW() + ) + `); + + // Insert a test record + const insertResult = await client.query( + 'INSERT INTO hyperdrive_test (message) VALUES ($1) RETURNING *', + [`Test from Hyperdrive at ${new Date().toISOString()}`] + ); + + // Query recent records + const selectResult = await client.query( + 'SELECT * FROM hyperdrive_test ORDER BY created_at DESC LIMIT 5' + ); + + await client.end(); + + return new Response(JSON.stringify({ + status: 'success', + message: 'Database operations completed successfully', + inserted: insertResult.rows[0], + recent_records: selectResult.rows, + performance: { + hyperdrive_enabled: true, + connection_pooled: true + } + }, null, 2), { + headers: { 'Content-Type': 'application/json' } + }); + } catch (error) { + return new Response(JSON.stringify({ + status: 'error', + message: 'Database query failed', + error: error.message + }, null, 2), { + status: 500, + headers: { 'Content-Type': 'application/json' } + }); + } +} \ No newline at end of file diff --git a/src/jixia/agents/memory_enhanced_agent.py b/src/jixia/agents/memory_enhanced_agent.py new file mode 100644 index 0000000..f4af5d5 --- /dev/null +++ b/src/jixia/agents/memory_enhanced_agent.py @@ -0,0 +1,535 @@ +#!/usr/bin/env python3 +""" +增强记忆的ADK智能体 +集成Vertex AI Memory Bank的稷下学宫智能体 +""" + +import asyncio +from typing import Dict, List, Optional, Any +from dataclasses import dataclass + +try: + from google.adk import Agent, InvocationContext + ADK_AVAILABLE = True +except ImportError: + ADK_AVAILABLE = False + print("⚠️ Google ADK 未安装") + InvocationContext = Any + +from src.jixia.memory.base_memory_bank import MemoryBankProtocol +from src.jixia.memory.factory import get_memory_backend +from config.doppler_config import get_google_genai_config + + +@dataclass +class BaxianPersonality: + """八仙智能体人格定义""" + name: str + chinese_name: str + hexagram: str # 对应的易经卦象 + investment_style: str + personality_traits: List[str] + debate_approach: str + memory_focus: List[str] # 重点记忆的内容类型 + + +class MemoryEnhancedAgent: + """ + 集成记忆银行的智能体 + 为稷下学宫八仙提供持久化记忆能力 + """ + + # 八仙人格定义 + BAXIAN_PERSONALITIES = { + "tieguaili": BaxianPersonality( + name="tieguaili", + chinese_name="铁拐李", + hexagram="巽卦", + investment_style="逆向投资大师", + personality_traits=["逆向思维", "挑战共识", "独立判断", "风险敏感"], + debate_approach="质疑主流观点，提出反向思考", + memory_focus=["市场异常", "逆向案例", "风险警示", "反向策略"] + ), + "hanzhongli": BaxianPersonality( + name="hanzhongli", + chinese_name="汉钟离", + hexagram="离卦", + investment_style="平衡协调者", + personality_traits=["平衡思维", "综合分析", "稳健决策", "协调统筹"], + debate_approach="寻求各方观点的平衡点", + memory_focus=["平衡策略", "综合分析", "协调方案", "稳健建议"] + ), + "zhangguolao": BaxianPersonality( + name="zhangguolao", + chinese_name="张果老", + hexagram="兑卦", + investment_style="历史智慧者", + personality_traits=["博古通今", "历史视角", "经验丰富", "智慧深邃"], + debate_approach="引用历史案例和长期趋势", + memory_focus=["历史案例", "长期趋势", "周期规律", "经验教训"] + ), + "lancaihe": BaxianPersonality( + name="lancaihe", + chinese_name="蓝采和", + hexagram="坎卦", + investment_style="创新思维者", + personality_traits=["创新思维", "潜力发现", "灵活变通", "机会敏锐"], + debate_approach="发现新兴机会和创新角度", + memory_focus=["创新机会", "新兴趋势", "潜力发现", "灵活策略"] + ), + "hexiangu": BaxianPersonality( + name="hexiangu", + chinese_name="何仙姑", + hexagram="坤卦", + investment_style="直觉洞察者", + personality_traits=["直觉敏锐", "情感智慧", "温和坚定", "洞察人心"], + debate_approach="基于直觉和情感智慧的分析", + memory_focus=["市场情绪", "直觉判断", "情感因素", "人性洞察"] + ), + "lvdongbin": BaxianPersonality( + name="lvdongbin", + chinese_name="吕洞宾", + hexagram="乾卦", + investment_style="理性分析者", + personality_traits=["理性客观", "逻辑严密", "技术精通", "决策果断"], + debate_approach="基于数据和逻辑的严密分析", + memory_focus=["技术分析", "数据洞察", "逻辑推理", "理性决策"] + ), + "hanxiangzi": BaxianPersonality( + name="hanxiangzi", + chinese_name="韩湘子", + hexagram="艮卦", + investment_style="艺术感知者", + personality_traits=["艺术感知", "美学视角", "创意思维", "感性理解"], + debate_approach="从美学和艺术角度分析市场", + memory_focus=["美学趋势", "创意洞察", "感性分析", "艺术视角"] + ), + "caoguojiu": BaxianPersonality( + name="caoguojiu", + chinese_name="曹国舅", + hexagram="震卦", + investment_style="实务执行者", + personality_traits=["实务导向", "执行力强", "机构视角", "专业严谨"], + debate_approach="关注实际执行和机构操作", + memory_focus=["执行策略", "机构动向", "实务操作", "专业分析"] + ) + } + + def __init__(self, agent_name: str, memory_bank: MemoryBankProtocol | None = None): + """ + 初始化记忆增强智能体 + + Args: + agent_name: 智能体名称 (如 "tieguaili") + memory_bank: 记忆银行实例 + """ + if not ADK_AVAILABLE: + raise ImportError("Google ADK 未安装，无法创建智能体") + + if agent_name not in self.BAXIAN_PERSONALITIES: + raise ValueError(f"未知的智能体: {agent_name}") + + self.agent_name = agent_name + self.personality = self.BAXIAN_PERSONALITIES[agent_name] + self.memory_bank = memory_bank + self.adk_agent = None + + # 初始化ADK智能体 + self._initialize_adk_agent() + + def _initialize_adk_agent(self): + """初始化ADK智能体""" + try: + # 构建智能体系统提示 + system_prompt = self._build_system_prompt() + + # 创建ADK智能体 + self.adk_agent = Agent( + name=self.personality.chinese_name, + model="gemini-2.0-flash-exp", + system_prompt=system_prompt, + temperature=0.7 + ) + + print(f"✅ 创建ADK智能体: {self.personality.chinese_name}") + + except Exception as e: + print(f"❌ 创建ADK智能体失败: {e}") + raise + + def _build_system_prompt(self) -> str: + """构建智能体系统提示""" + return f""" +# {self.personality.chinese_name} - {self.personality.investment_style} + +## 角色定位 +你是稷下学宫的{self.personality.chinese_name}，对应易经{self.personality.hexagram}，专精于{self.personality.investment_style}。 + +## 人格特质 +{', '.join(self.personality.personality_traits)} + +## 辩论风格 +{self.personality.debate_approach} + +## 记忆重点 +你特别关注并记住以下类型的信息： +{', '.join(self.personality.memory_focus)} + +## 行为准则 +1. 始终保持你的人格特质和投资风格 +2. 在辩论中体现你的独特视角 +3. 学习并记住重要的讨论内容 +4. 与其他七仙协作，但保持独立观点 +5. 基于历史记忆提供更有深度的分析 + +## 记忆运用 +- 在回答前，会参考相关的历史记忆 +- 学习用户偏好，调整沟通风格 +- 记住成功的策略和失败的教训 +- 与其他智能体分享有价值的洞察 + +请始终以{self.personality.chinese_name}的身份进行对话和分析。 +""" + + async def get_memory_context(self, topic: str) -> str: + """ + 获取与主题相关的记忆上下文 + + Args: + topic: 讨论主题 + + Returns: + 格式化的记忆上下文 + """ + if not self.memory_bank: + return "" + + try: + context = await self.memory_bank.get_agent_context( + self.agent_name, topic + ) + return context + except Exception as e: + print(f"⚠️ 获取记忆上下文失败: {e}") + return "" + + async def respond_with_memory(self, + message: str, + topic: str = "", + context: InvocationContext = None) -> str: + """ + 基于记忆增强的响应 + + Args: + message: 输入消息 + topic: 讨论主题 + context: ADK调用上下文 + + Returns: + 智能体响应 + """ + try: + # 获取记忆上下文 + memory_context = await self.get_memory_context(topic) + + # 构建增强的提示 + enhanced_prompt = f""" +{memory_context} + +## 当前讨论 +主题: {topic} +消息: {message} + +请基于你的记忆和人格特质进行回应。 +""" + + # 使用ADK生成响应 + if context is None: + context = InvocationContext() + + response_generator = self.adk_agent.run_async( + enhanced_prompt, + context=context + ) + + # 收集响应 + response_parts = [] + async for chunk in response_generator: + if hasattr(chunk, 'text'): + response_parts.append(chunk.text) + elif isinstance(chunk, str): + response_parts.append(chunk) + + response = ''.join(response_parts) + + # 保存对话记忆 + if self.memory_bank and response: + await self._save_conversation_memory(message, response, topic) + + return response + + except Exception as e: + print(f"❌ 生成响应失败: {e}") + return f"抱歉，{self.personality.chinese_name}暂时无法回应。" + + async def _save_conversation_memory(self, + user_message: str, + agent_response: str, + topic: str): + """ + 保存对话记忆 + + Args: + user_message: 用户消息 + agent_response: 智能体响应 + topic: 讨论主题 + """ + try: + # 保存用户消息记忆 + await self.memory_bank.add_memory( + agent_name=self.agent_name, + content=f"用户询问: {user_message}", + memory_type="conversation", + debate_topic=topic, + metadata={"role": "user"} + ) + + # 保存智能体响应记忆 + await self.memory_bank.add_memory( + agent_name=self.agent_name, + content=f"我的回应: {agent_response}", + memory_type="conversation", + debate_topic=topic, + metadata={"role": "assistant"} + ) + + except Exception as e: + print(f"⚠️ 保存对话记忆失败: {e}") + + async def learn_preference(self, preference: str, topic: str = ""): + """ + 学习用户偏好 + + Args: + preference: 偏好描述 + topic: 相关主题 + """ + if not self.memory_bank: + return + + try: + await self.memory_bank.add_memory( + agent_name=self.agent_name, + content=f"用户偏好: {preference}", + memory_type="preference", + debate_topic=topic, + metadata={"learned_from": "user_feedback"} + ) + + print(f"✅ {self.personality.chinese_name} 学习了新偏好") + + except Exception as e: + print(f"⚠️ 学习偏好失败: {e}") + + async def save_strategy_insight(self, insight: str, topic: str = ""): + """ + 保存策略洞察 + + Args: + insight: 策略洞察 + topic: 相关主题 + """ + if not self.memory_bank: + return + + try: + await self.memory_bank.add_memory( + agent_name=self.agent_name, + content=f"策略洞察: {insight}", + memory_type="strategy", + debate_topic=topic, + metadata={"insight_type": "strategy"} + ) + + print(f"✅ {self.personality.chinese_name} 保存了策略洞察") + + except Exception as e: + print(f"⚠️ 保存策略洞察失败: {e}") + + +class BaxianMemoryCouncil: + """ + 八仙记忆议会 + 管理所有八仙智能体的记忆增强功能 + """ + + def __init__(self, memory_bank: MemoryBankProtocol | None = None): + """ + 初始化八仙记忆议会 + + Args: + memory_bank: 记忆银行实例 + """ + self.memory_bank = memory_bank + self.agents = {} + + # 初始化所有八仙智能体 + self._initialize_agents() + + def _initialize_agents(self): + """初始化所有八仙智能体""" + for agent_name in MemoryEnhancedAgent.BAXIAN_PERSONALITIES.keys(): + try: + agent = MemoryEnhancedAgent(agent_name, self.memory_bank) + self.agents[agent_name] = agent + print(f"✅ 初始化 {agent.personality.chinese_name}") + except Exception as e: + print(f"❌ 初始化 {agent_name} 失败: {e}") + + async def conduct_memory_debate(self, + topic: str, + participants: List[str] = None, + rounds: int = 3) -> Dict[str, Any]: + """ + 进行记忆增强的辩论 + + Args: + topic: 辩论主题 + participants: 参与者列表，None表示所有八仙 + rounds: 辩论轮数 + + Returns: + 辩论结果 + """ + if participants is None: + participants = list(self.agents.keys()) + + conversation_history = [] + context = InvocationContext() + + print(f"🏛️ 稷下学宫八仙论道开始: {topic}") + + for round_num in range(rounds): + print(f"\n--- 第 {round_num + 1} 轮 ---") + + for agent_name in participants: + if agent_name not in self.agents: + continue + + agent = self.agents[agent_name] + + # 构建当前轮次的提示 + round_prompt = f""" +轮次: {round_num + 1}/{rounds} +主题: {topic} + +请基于你的记忆和人格特质，对此主题发表观点。 +如果这不是第一轮，请考虑其他仙友的观点并做出回应。 +""" + + # 获取响应 + response = await agent.respond_with_memory( + round_prompt, topic, context + ) + + # 记录对话历史 + conversation_history.append({ + "round": round_num + 1, + "agent": agent_name, + "chinese_name": agent.personality.chinese_name, + "content": response + }) + + print(f"{agent.personality.chinese_name}: {response[:100]}...") + + # 保存辩论会话到记忆银行 + if self.memory_bank: + await self.memory_bank.save_debate_session( + debate_topic=topic, + participants=participants, + conversation_history=conversation_history + ) + + return { + "topic": topic, + "participants": participants, + "rounds": rounds, + "conversation_history": conversation_history, + "total_exchanges": len(conversation_history) + } + + async def get_collective_memory_summary(self, topic: str) -> str: + """ + 获取集体记忆摘要 + + Args: + topic: 主题 + + Returns: + 集体记忆摘要 + """ + if not self.memory_bank: + return "记忆银行未启用" + + summaries = [] + + for agent_name, agent in self.agents.items(): + context = await agent.get_memory_context(topic) + if context and context.strip(): + summaries.append(context) + + if summaries: + return f"# 稷下学宫集体记忆摘要\n\n" + "\n\n".join(summaries) + else: + return "暂无相关集体记忆" + + +# 便捷函数 +async def create_memory_enhanced_council() -> BaxianMemoryCouncil: + """ + 创建记忆增强的八仙议会 + + Returns: + 配置好的BaxianMemoryCouncil实例 + """ + try: + # 初始化记忆银行 + memory_bank = get_memory_backend() + + # 创建八仙议会 + council = BaxianMemoryCouncil(memory_bank) + + print("🏛️ 稷下学宫记忆增强议会创建完成") + return council + + except Exception as e: + print(f"❌ 创建记忆增强议会失败: {e}") + # 创建无记忆版本 + return BaxianMemoryCouncil(None) + + +if __name__ == "__main__": + async def test_memory_enhanced_agent(): + """测试记忆增强智能体""" + try: + # 创建记忆增强议会 + council = await create_memory_enhanced_council() + + # 进行记忆增强辩论 + result = await council.conduct_memory_debate( + topic="NVIDIA股票投资分析", + participants=["tieguaili", "lvdongbin", "hexiangu"], + rounds=2 + ) + + print(f"\n🏛️ 辩论完成，共 {result['total_exchanges']} 次发言") + + # 获取集体记忆摘要 + summary = await council.get_collective_memory_summary("NVIDIA股票投资分析") + print(f"\n📚 集体记忆摘要:\n{summary}") + + except Exception as e: + print(f"❌ 测试失败: {e}") + + # 运行测试 + asyncio.run(test_memory_enhanced_agent()) diff --git a/src/jixia/config/immortal_api_config.json b/src/jixia/config/immortal_api_config.json new file mode 100644 index 0000000..4349af0 --- /dev/null +++ b/src/jixia/config/immortal_api_config.json @@ -0,0 +1,216 @@ +{ + "immortals": { + "吕洞宾": { + "title": "主力剑仙", + "specialty": "综合分析与决策", + "description": "作为八仙之首，负责整体投资策略制定，需要最快最准确的数据", + "preferred_apis": { + "stock_quote": "alpha_vantage", + "company_overview": "alpha_vantage", + "market_movers": "yahoo_finance_15", + "market_news": "yahoo_finance_15" + }, + "data_priority": ["实时价格", "公司基本面", "市场动态"], + "api_weight": 0.15 + }, + "何仙姑": { + "title": "风控专家", + "specialty": "风险管理与合规", + "description": "专注风险评估和投资组合管理，需要稳定可靠的数据源", + "preferred_apis": { + "stock_quote": "yahoo_finance_15", + "company_overview": "seeking_alpha", + "market_movers": "webull", + "market_news": "seeking_alpha" + }, + "data_priority": ["波动率", "风险指标", "合规信息"], + "api_weight": 0.12 + }, + "张果老": { + "title": "技术分析师", + "specialty": "技术指标与图表分析", + "description": "专精技术分析，需要详细的价格和成交量数据", + "preferred_apis": { + "stock_quote": "webull", + "company_overview": "alpha_vantage", + "market_movers": "yahoo_finance_15", + "market_news": "yahoo_finance_15" + }, + "data_priority": ["技术指标", "成交量", "价格走势"], + "api_weight": 0.13 + }, + "韩湘子": { + "title": "基本面研究员", + "specialty": "财务分析与估值", + "description": "深度研究公司财务状况和内在价值", + "preferred_apis": { + "stock_quote": "alpha_vantage", + "company_overview": "seeking_alpha", + "market_movers": "webull", + "market_news": "seeking_alpha" + }, + "data_priority": ["财务报表", "估值指标", "盈利预测"], + "api_weight": 0.14 + }, + "汉钟离": { + "title": "量化专家", + "specialty": "数据挖掘与算法交易", + "description": "运用数学模型和算法进行量化分析", + "preferred_apis": { + "stock_quote": "yahoo_finance_15", + "company_overview": "alpha_vantage", + "market_movers": "yahoo_finance_15", + "market_news": "yahoo_finance_15" + }, + "data_priority": ["历史数据", "统计指标", "相关性分析"], + "api_weight": 0.13 + }, + "蓝采和": { + "title": "情绪分析师", + "specialty": "市场情绪与舆情监控", + "description": "分析市场情绪和投资者行为模式", + "preferred_apis": { + "stock_quote": "webull", + "company_overview": "seeking_alpha", + "market_movers": "webull", + "market_news": "seeking_alpha" + }, + "data_priority": ["新闻情绪", "社交媒体", "投资者情绪"], + "api_weight": 0.11 + }, + "曹国舅": { + "title": "宏观分析师", + "specialty": "宏观经济与政策分析", + "description": "关注宏观经济环境和政策影响", + "preferred_apis": { + "stock_quote": "seeking_alpha", + "company_overview": "seeking_alpha", + "market_movers": "yahoo_finance_15", + "market_news": "seeking_alpha" + }, + "data_priority": ["宏观数据", "政策解读", "行业趋势"], + "api_weight": 0.12 + }, + "铁拐李": { + "title": "逆向投资专家", + "specialty": "价值发现与逆向思维", + "description": "寻找被低估的投资机会，逆向思考市场", + "preferred_apis": { + "stock_quote": "alpha_vantage", + "company_overview": "alpha_vantage", + "market_movers": "webull", + "market_news": "yahoo_finance_15" + }, + "data_priority": ["估值偏差", "市场异常", "价值机会"], + "api_weight": 0.10 + } + }, + "api_configurations": { + "alpha_vantage": { + "name": "Alpha Vantage", + "tier": "premium", + "strengths": ["实时数据", "财务数据", "技术指标"], + "rate_limits": { + "per_minute": 500, + "per_month": 500000 + }, + "reliability_score": 0.95, + "response_time_avg": 0.8, + "data_quality": "high", + "cost_per_call": 0.001 + }, + "yahoo_finance_15": { + "name": "Yahoo Finance 15", + "tier": "standard", + "strengths": ["市场数据", "新闻资讯", "实时报价"], + "rate_limits": { + "per_minute": 500, + "per_month": 500000 + }, + "reliability_score": 0.90, + "response_time_avg": 1.2, + "data_quality": "medium", + "cost_per_call": 0.0005 + }, + "webull": { + "name": "Webull", + "tier": "premium", + "strengths": ["搜索功能", "活跃数据", "技术分析"], + "rate_limits": { + "per_minute": 500, + "per_month": 500000 + }, + "reliability_score": 0.88, + "response_time_avg": 1.0, + "data_quality": "high", + "cost_per_call": 0.0008 + }, + "seeking_alpha": { + "name": "Seeking Alpha", + "tier": "standard", + "strengths": ["分析报告", "新闻资讯", "专业观点"], + "rate_limits": { + "per_minute": 500, + "per_month": 500000 + }, + "reliability_score": 0.85, + "response_time_avg": 1.5, + "data_quality": "medium", + "cost_per_call": 0.0006 + } + }, + "load_balancing_strategies": { + "round_robin": { + "description": "轮询分配，确保负载均匀分布", + "enabled": true, + "weight_based": true + }, + "health_aware": { + "description": "基于API健康状态的智能分配", + "enabled": true, + "health_check_interval": 300 + }, + "performance_based": { + "description": "基于响应时间的动态分配", + "enabled": true, + "response_time_threshold": 2.0 + }, + "cost_optimization": { + "description": "成本优化策略，优先使用低成本API", + "enabled": false, + "cost_threshold": 0.001 + } + }, + "failover_matrix": { + "alpha_vantage": ["webull", "yahoo_finance_15", "seeking_alpha"], + "yahoo_finance_15": ["webull", "alpha_vantage", "seeking_alpha"], + "webull": ["alpha_vantage", "yahoo_finance_15", "seeking_alpha"], + "seeking_alpha": ["yahoo_finance_15", "alpha_vantage", "webull"] + }, + "cache_settings": { + "enabled": true, + "ttl_seconds": 300, + "max_entries": 1000, + "cache_strategies": { + "stock_quote": 60, + "company_overview": 3600, + "market_movers": 300, + "market_news": 1800 + } + }, + "monitoring": { + "enabled": true, + "metrics": [ + "api_call_count", + "response_time", + "error_rate", + "cache_hit_rate", + "load_distribution" + ], + "alerts": { + "high_error_rate": 0.1, + "slow_response_time": 3.0, + "api_unavailable": true + } + } +} \ No newline at end of file diff --git a/src/jixia/debates/adk_debate_test.py b/src/jixia/debates/adk_debate_test.py new file mode 100644 index 0000000..095510f --- /dev/null +++ b/src/jixia/debates/adk_debate_test.py @@ -0,0 +1,130 @@ +#!/usr/bin/env python3 +# -*- coding: utf-8 -*- +""" +稷下学宫 Google ADK 论道系统测试 +基于 Google ADK 的八仙论道原型 +""" + +import os +import asyncio +from google.adk import Agent +from google.adk.tools import FunctionTool + +# 八仙智能体定义 +def create_baxian_agents(): + """创建八仙智能体""" + + # 铁拐李 - 逆向思维专家 + tie_guai_li = Agent( + name="铁拐李", + model="gemini-2.0-flash-exp" + ) + + # 汉钟离 - 平衡协调者 + han_zhong_li = Agent( + name="汉钟离", + model="gemini-2.0-flash-exp" + ) + + # 张果老 - 历史智慧者 + zhang_guo_lao = Agent( + name="张果老", + model="gemini-2.0-flash-exp" + ) + + # 蓝采和 - 创新思维者 + lan_cai_he = Agent( + name="蓝采和", + model="gemini-2.0-flash-exp" + ) + + # 何仙姑 - 直觉洞察者 + he_xian_gu = Agent( + name="何仙姑", + model="gemini-2.0-flash-exp" + ) + + # 吕洞宾 - 理性分析者 + lu_dong_bin = Agent( + name="吕洞宾", + model="gemini-2.0-flash-exp" + ) + + # 韩湘子 - 艺术感知者 + han_xiang_zi = Agent( + name="韩湘子", + model="gemini-2.0-flash-exp" + ) + + # 曹国舅 - 实务执行者 + cao_guo_jiu = Agent( + name="曹国舅", + model="gemini-2.0-flash-exp" + ) + + return { + "铁拐李": tie_guai_li, + "汉钟离": han_zhong_li, + "张果老": zhang_guo_lao, + "蓝采和": lan_cai_he, + "何仙姑": he_xian_gu, + "吕洞宾": lu_dong_bin, + "韩湘子": han_xiang_zi, + "曹国舅": cao_guo_jiu + } + +def test_single_agent(): + """测试单个智能体""" + print("🧪 测试单个智能体...") + + # 创建铁拐李智能体 + tie_guai_li = Agent( + name="铁拐李", + model="gemini-2.0-flash-exp" + ) + + print(f"✅ 智能体 '{tie_guai_li.name}' 创建成功") + print(f"📱 使用模型: {tie_guai_li.model}") + + return tie_guai_li + +def test_baxian_creation(): + """测试八仙智能体创建""" + print("\n🎭 创建八仙智能体...") + + baxian = create_baxian_agents() + + print(f"✅ 成功创建 {len(baxian)} 个智能体:") + for name, agent in baxian.items(): + print(f" - {name}: {agent.model}") + + return baxian + +def main(): + """主测试函数""" + print("🚀 开始稷下学宫 ADK 论道系统测试...") + + # 检查API密钥 + api_key = os.getenv('GOOGLE_API_KEY') + if not api_key: + print("❌ 未找到 GOOGLE_API_KEY 环境变量") + print("请使用: doppler run -- python src/jixia/debates/adk_debate_test.py") + return + + print(f"✅ API密钥已配置 (长度: {len(api_key)} 字符)") + + # 测试单个智能体 + single_agent = test_single_agent() + + # 测试八仙智能体创建 + baxian = test_baxian_creation() + + print("\n🎉 ADK 论道系统基础测试完成！") + print("\n📝 下一步:") + print(" 1. 实现智能体间的对话逻辑") + print(" 2. 集成 RapidAPI 数据源") + print(" 3. 创建论道主题和流程") + print(" 4. 连接 Streamlit 界面") + +if __name__ == "__main__": + main() \ No newline at end of file diff --git a/src/jixia/debates/adk_memory_debate.py b/src/jixia/debates/adk_memory_debate.py new file mode 100644 index 0000000..3915f92 --- /dev/null +++ b/src/jixia/debates/adk_memory_debate.py @@ -0,0 +1,282 @@ +#!/usr/bin/env python3 +# -*- coding: utf-8 -*- +""" +稷下学宫 ADK Memory Bank 论道系统 +实现带有记忆银行的八仙智能体辩论 +""" + +import os +import asyncio +from google.adk import Agent, Runner +from google.adk.sessions import InMemorySessionService +from google.adk.memory import MemoryBank, MemoryItem +from google.genai import types +import json +from datetime import datetime +from typing import Dict, List, Optional + +class BaxianMemoryManager: + """八仙记忆管理器""" + + def __init__(self): + self.memory_banks: Dict[str, MemoryBank] = {} + self.agents: Dict[str, Agent] = {} + + async def initialize_baxian_agents(self): + """初始化八仙智能体及其记忆银行""" + + # 八仙角色配置 + baxian_config = { + "铁拐李": { + "instruction": "你是铁拐李，八仙中的逆向思维专家。你善于从批判和质疑的角度看问题，总是能发现事物的另一面。你会从你的记忆中回忆相关的逆向投资案例和失败教训。", + "memory_context": "逆向投资案例、市场泡沫警告、风险识别经验" + }, + "吕洞宾": { + "instruction": "你是吕洞宾，八仙中的理性分析者。你善于平衡各方观点，用理性和逻辑来分析问题。你会从记忆中调用技术分析的成功案例和理论知识。", + "memory_context": "技术分析理论、成功预测案例、市场趋势分析" + }, + "何仙姑": { + "instruction": "你是何仙姑，八仙中的风险控制专家。你总是从风险管理的角度思考问题，善于发现潜在危险。你会回忆历史上的重大风险事件。", + "memory_context": "风险管理案例、黑天鹅事件、危机预警经验" + }, + "张果老": { + "instruction": "你是张果老，八仙中的历史智慧者。你善于从历史数据中寻找规律和智慧，总是能提供长期视角。你会从记忆中调用历史数据和长期趋势。", + "memory_context": "历史市场数据、长期投资趋势、周期性规律" + } + } + + # 为每个仙人创建智能体和记忆银行 + for name, config in baxian_config.items(): + # 创建记忆银行 + memory_bank = MemoryBank( + name=f"{name}_memory_bank", + description=f"{name}的个人记忆银行，存储{config['memory_context']}" + ) + + # 初始化记忆内容 + await self._initialize_agent_memory(memory_bank, name, config['memory_context']) + + # 创建智能体 + agent = Agent( + name=name, + model="gemini-2.0-flash-exp", + instruction=f"{config['instruction']} 在回答时，请先从你的记忆银行中检索相关信息，然后结合当前话题给出回应。", + memory_bank=memory_bank + ) + + self.memory_banks[name] = memory_bank + self.agents[name] = agent + + print(f"✅ 已初始化 {len(self.agents)} 个八仙智能体及其记忆银行") + + async def _initialize_agent_memory(self, memory_bank: MemoryBank, agent_name: str, context: str): + """为智能体初始化记忆内容""" + + # 根据角色添加初始记忆 + initial_memories = { + "铁拐李": [ + "2000年互联网泡沫破裂，许多高估值科技股暴跌90%以上", + "2008年金融危机前，房地产市场过度繁荣，逆向思维者提前撤离", + "比特币从2万美元跌到3千美元，提醒我们任何资产都可能大幅回调", + "巴菲特说过：别人贪婪时我恐惧，别人恐惧时我贪婪" + ], + "吕洞宾": [ + "移动平均线交叉是经典的技术分析信号", + "RSI指标超过70通常表示超买，低于30表示超卖", + "支撑位和阻力位是技术分析的核心概念", + "成功的技术分析需要结合多个指标综合判断" + ], + "何仙姑": [ + "2008年雷曼兄弟倒闭引发全球金融危机", + "长期资本管理公司(LTCM)的失败说明了风险管理的重要性", + "分散投资是降低风险的基本原则", + "黑天鹅事件虽然罕见但影响巨大，需要提前准备" + ], + "张果老": [ + "股市存在7-10年的长期周期", + "康德拉季耶夫长波理论描述了50-60年的经济周期", + "历史上每次重大技术革命都带来新的投资机会", + "长期来看，优质资产总是向上的" + ] + } + + memories = initial_memories.get(agent_name, []) + for memory_text in memories: + memory_item = MemoryItem( + content=memory_text, + metadata={ + "agent": agent_name, + "type": "historical_knowledge", + "timestamp": datetime.now().isoformat() + } + ) + await memory_bank.add_memory(memory_item) + + async def add_debate_memory(self, agent_name: str, content: str, topic: str): + """为智能体添加辩论记忆""" + if agent_name in self.memory_banks: + memory_item = MemoryItem( + content=content, + metadata={ + "agent": agent_name, + "type": "debate_history", + "topic": topic, + "timestamp": datetime.now().isoformat() + } + ) + await self.memory_banks[agent_name].add_memory(memory_item) + + async def retrieve_relevant_memories(self, agent_name: str, query: str, limit: int = 3) -> List[str]: + """检索智能体的相关记忆""" + if agent_name not in self.memory_banks: + return [] + + try: + memories = await self.memory_banks[agent_name].search(query, limit=limit) + return [memory.content for memory in memories] + except Exception as e: + print(f"⚠️ 记忆检索失败 ({agent_name}): {e}") + return [] + +class MemoryEnhancedDebate: + """带记忆增强的辩论系统""" + + def __init__(self): + self.memory_manager = BaxianMemoryManager() + self.session_service = InMemorySessionService() + self.runners: Dict[str, Runner] = {} + + async def initialize(self): + """初始化辩论系统""" + await self.memory_manager.initialize_baxian_agents() + + # 创建会话 + self.session = await self.session_service.create_session( + state={}, + app_name="稷下学宫记忆增强论道系统", + user_id="memory_debate_user" + ) + + # 为每个智能体创建Runner + for name, agent in self.memory_manager.agents.items(): + runner = Runner( + app_name="稷下学宫记忆增强论道系统", + agent=agent, + session_service=self.session_service + ) + self.runners[name] = runner + + async def conduct_memory_debate(self, topic: str, participants: List[str] = None): + """进行带记忆的辩论""" + if participants is None: + participants = ["铁拐李", "吕洞宾", "何仙姑", "张果老"] + + print(f"\n🎭 稷下学宫记忆增强论道开始...") + print(f"📋 论道主题: {topic}") + print(f"🎯 参与仙人: {', '.join(participants)}") + + debate_history = [] + + for round_num in range(2): # 进行2轮辩论 + print(f"\n🔄 第 {round_num + 1} 轮论道:") + + for participant in participants: + if participant not in self.runners: + continue + + print(f"\n🗣️ {participant} 发言:") + + # 检索相关记忆 + relevant_memories = await self.memory_manager.retrieve_relevant_memories( + participant, topic, limit=2 + ) + + # 构建包含记忆的提示 + memory_context = "" + if relevant_memories: + memory_context = f"\n从你的记忆中回忆到：\n" + "\n".join([f"- {memory}" for memory in relevant_memories]) + + # 构建辩论历史上下文 + history_context = "" + if debate_history: + recent_history = debate_history[-3:] # 最近3条发言 + history_context = f"\n最近的论道内容：\n" + "\n".join([f"- {h}" for h in recent_history]) + + prompt = f"关于'{topic}'这个话题{memory_context}{history_context}\n\n请结合你的记忆和当前讨论，从你的角色特点出发发表观点。请控制在150字以内。" + + # 发送消息并获取回复 + content = types.Content(role='user', parts=[types.Part(text=prompt)]) + response = self.runners[participant].run_async( + user_id=self.session.user_id, + session_id=self.session.id, + new_message=content + ) + + # 收集回复 + reply = "" + async for event in response: + if hasattr(event, 'content') and event.content: + if hasattr(event.content, 'parts') and event.content.parts: + for part in event.content.parts: + if hasattr(part, 'text') and part.text: + reply += str(part.text) + + if reply.strip(): + clean_reply = reply.strip() + print(f" {clean_reply}") + + # 记录到辩论历史 + debate_entry = f"{participant}: {clean_reply}" + debate_history.append(debate_entry) + + # 添加到记忆银行 + await self.memory_manager.add_debate_memory( + participant, clean_reply, topic + ) + + await asyncio.sleep(1) # 避免API调用过快 + + print(f"\n🎉 记忆增强论道完成！") + print(f"📝 本次论道共产生 {len(debate_history)} 条发言，已存储到各仙人的记忆银行中。") + + return debate_history + + async def close(self): + """关闭资源""" + for runner in self.runners.values(): + await runner.close() + +async def main(): + """主函数""" + print("🚀 稷下学宫 ADK Memory Bank 论道系统") + + # 检查API密钥 + api_key = os.getenv('GOOGLE_API_KEY') + if not api_key: + print("❌ 未找到 GOOGLE_API_KEY 环境变量") + print("请使用: doppler run -- python src/jixia/debates/adk_memory_debate.py") + return + + print(f"✅ API密钥已配置") + + # 创建并初始化辩论系统 + debate_system = MemoryEnhancedDebate() + + try: + await debate_system.initialize() + + # 进行辩论 + await debate_system.conduct_memory_debate( + topic="人工智能对投资市场的影响", + participants=["铁拐李", "吕洞宾", "何仙姑", "张果老"] + ) + + except Exception as e: + print(f"❌ 运行失败: {e}") + import traceback + traceback.print_exc() + finally: + await debate_system.close() + +if __name__ == "__main__": + asyncio.run(main()) \ No newline at end of file diff --git a/src/jixia/debates/adk_real_debate.py b/src/jixia/debates/adk_real_debate.py new file mode 100644 index 0000000..d15ca0b --- /dev/null +++ b/src/jixia/debates/adk_real_debate.py @@ -0,0 +1,252 @@ +#!/usr/bin/env python3 +# -*- coding: utf-8 -*- +""" +稷下学宫 ADK 真实论道系统 +实现铁拐李和吕洞宾的实际对话辩论 +""" + +import os +import asyncio +from google.adk import Agent, Runner +from google.adk.sessions import InMemorySessionService +from google.genai import types +import re +import sys +from contextlib import contextmanager + +def create_debate_agents(): + """创建论道智能体""" + + # 铁拐李 - 逆向思维专家 + tie_guai_li = Agent( + name="铁拐李", + model="gemini-2.0-flash-exp", + instruction="你是铁拐李，八仙中的逆向思维专家。你善于从批判和质疑的角度看问题，总是能发现事物的另一面。你的发言风格直接、犀利，但富有智慧。每次发言控制在100字以内。" + ) + + # 吕洞宾 - 理性分析者 + lu_dong_bin = Agent( + name="吕洞宾", + model="gemini-2.0-flash-exp", + instruction="你是吕洞宾，八仙中的理性分析者。你善于平衡各方观点，用理性和逻辑来分析问题。你的发言风格温和而深刻，总是能找到问题的核心。每次发言控制在100字以内。" + ) + + return tie_guai_li, lu_dong_bin + +async def conduct_debate(): + """进行实际辩论""" + print("🎭 稷下学宫论道开始...") + + # 创建智能体 + tie_guai_li, lu_dong_bin = create_debate_agents() + + print("\n📋 论道主题: 人工智能对未来社会的影响") + print("\n🎯 八仙论道，智慧交锋...") + + try: + print("\n🚀 使用真实ADK调用进行论道...") + await real_adk_debate(tie_guai_li, lu_dong_bin) + except Exception as e: + print(f"\n❌ ADK调用失败: {e}") + print("🔧 回退到模拟对话模式...") + await simple_mock_debate(tie_guai_li, lu_dong_bin) + +@contextmanager +def suppress_stdout(): + """临时抑制stdout输出""" + with open(os.devnull, 'w') as devnull: + old_stdout = sys.stdout + sys.stdout = devnull + try: + yield + finally: + sys.stdout = old_stdout + +def clean_debug_output(text): + """清理ADK输出中的调试信息""" + if not text: + return "" + + # 移除API密钥相关信息 + text = re.sub(r'Both GOOGLE_API_KEY and GEMINI_API_KEY are set\. Using GOOGLE_API_KEY\.', '', text) + + # 移除Event from unknown agent信息 + text = re.sub(r'Event from an unknown agent: [^\n]*\n?', '', text) + + # 移除多余的空白字符 + text = re.sub(r'\n\s*\n', '\n', text) + text = text.strip() + + return text + +async def real_adk_debate(tie_guai_li, lu_dong_bin): + """使用真实ADK进行辩论""" + print("\n🔥 真实ADK论道模式") + + # 设置环境变量来抑制ADK调试输出 + os.environ['GOOGLE_CLOUD_DISABLE_GRPC_LOGS'] = 'true' + os.environ['GRPC_VERBOSITY'] = 'NONE' + os.environ['GRPC_TRACE'] = '' + + # 临时抑制警告和调试信息 + import warnings + warnings.filterwarnings('ignore') + + # 设置日志级别 + import logging + logging.getLogger().setLevel(logging.ERROR) + + # 创建会话服务 + session_service = InMemorySessionService() + + # 创建会话 + session = await session_service.create_session( + state={}, + app_name="稷下学宫论道系统", + user_id="debate_user" + ) + + # 创建Runner实例 + tie_runner = Runner( + app_name="稷下学宫论道系统", + agent=tie_guai_li, + session_service=session_service + ) + + lu_runner = Runner( + app_name="稷下学宫论道系统", + agent=lu_dong_bin, + session_service=session_service + ) + + try: + # 第一轮：铁拐李开场 + print("\n🗣️ 铁拐李发言:") + tie_prompt = "作为逆向思维专家，请从批判角度分析人工智能对未来社会可能带来的负面影响。请控制在100字以内。" + + tie_content = types.Content(role='user', parts=[types.Part(text=tie_prompt)]) + with suppress_stdout(): + tie_response = tie_runner.run_async( + user_id=session.user_id, + session_id=session.id, + new_message=tie_content + ) + + tie_reply = "" + async for event in tie_response: + # 只处理包含实际文本内容的事件，过滤调试信息 + if hasattr(event, 'content') and event.content: + if hasattr(event.content, 'parts') and event.content.parts: + for part in event.content.parts: + if hasattr(part, 'text') and part.text and part.text.strip(): + text_content = str(part.text).strip() + # 过滤掉调试信息和系统消息 + if not text_content.startswith('Event from') and not 'API_KEY' in text_content: + tie_reply += text_content + elif hasattr(event, 'text') and event.text: + text_content = str(event.text).strip() + if not text_content.startswith('Event from') and not 'API_KEY' in text_content: + tie_reply += text_content + + # 清理并输出铁拐李的回复 + clean_tie_reply = clean_debug_output(tie_reply) + if clean_tie_reply: + print(f" {clean_tie_reply}") + + # 第二轮：吕洞宾回应 + print("\n🗣️ 吕洞宾回应:") + lu_prompt = f"铁拐李提到了AI的负面影响：'{tie_reply[:50]}...'。作为理性分析者，请从平衡角度回应，既承认风险又指出机遇。请控制在100字以内。" + + lu_content = types.Content(role='user', parts=[types.Part(text=lu_prompt)]) + with suppress_stdout(): + lu_response = lu_runner.run_async( + user_id=session.user_id, + session_id=session.id, + new_message=lu_content + ) + + lu_reply = "" + async for event in lu_response: + # 只处理包含实际文本内容的事件，过滤调试信息 + if hasattr(event, 'content') and event.content: + if hasattr(event.content, 'parts') and event.content.parts: + for part in event.content.parts: + if hasattr(part, 'text') and part.text and part.text.strip(): + text_content = str(part.text).strip() + # 过滤掉调试信息和系统消息 + if not text_content.startswith('Event from') and not 'API_KEY' in text_content: + lu_reply += text_content + elif hasattr(event, 'text') and event.text: + text_content = str(event.text).strip() + if not text_content.startswith('Event from') and not 'API_KEY' in text_content: + lu_reply += text_content + + # 清理并输出吕洞宾的回复 + clean_lu_reply = clean_debug_output(lu_reply) + if clean_lu_reply: + print(f" {clean_lu_reply}") + + # 第三轮：铁拐李再次发言 + print("\n🗣️ 铁拐李再次发言:") + tie_prompt2 = f"吕洞宾提到了AI的机遇：'{lu_reply[:50]}...'。请从逆向思维角度，对这些所谓的机遇进行质疑和反思。请控制在100字以内。" + + tie_content2 = types.Content(role='user', parts=[types.Part(text=tie_prompt2)]) + with suppress_stdout(): + tie_response2 = tie_runner.run_async( + user_id=session.user_id, + session_id=session.id, + new_message=tie_content2 + ) + + tie_reply2 = "" + async for event in tie_response2: + # 只处理包含实际文本内容的事件，过滤调试信息 + if hasattr(event, 'content') and event.content: + if hasattr(event.content, 'parts') and event.content.parts: + for part in event.content.parts: + if hasattr(part, 'text') and part.text and part.text.strip(): + text_content = str(part.text).strip() + # 过滤掉调试信息和系统消息 + if not text_content.startswith('Event from') and not 'API_KEY' in text_content: + tie_reply2 += text_content + elif hasattr(event, 'text') and event.text: + text_content = str(event.text).strip() + if not text_content.startswith('Event from') and not 'API_KEY' in text_content: + tie_reply2 += text_content + + # 清理并输出铁拐李的第二次回复 + clean_tie_reply2 = clean_debug_output(tie_reply2) + if clean_tie_reply2: + print(f" {clean_tie_reply2}") + + print("\n🎉 真实ADK论道完成！") + print("\n📝 智慧交锋，各抒己见，这就是稷下学宫的魅力所在。") + + finally: + # 清理资源 + await tie_runner.close() + await lu_runner.close() + + + +def main(): + """主函数""" + print("🚀 稷下学宫 ADK 真实论道系统") + + # 检查API密钥 + api_key = os.getenv('GOOGLE_API_KEY') + if not api_key: + print("❌ 未找到 GOOGLE_API_KEY 环境变量") + print("请使用: doppler run -- python src/jixia/debates/adk_real_debate.py") + return + + print(f"✅ API密钥已配置") + + # 运行异步辩论 + try: + asyncio.run(conduct_debate()) + except Exception as e: + print(f"❌ 运行失败: {e}") + +if __name__ == "__main__": + main() \ No newline at end of file diff --git a/src/jixia/debates/adk_simple_debate.py b/src/jixia/debates/adk_simple_debate.py new file mode 100644 index 0000000..bddbab5 --- /dev/null +++ b/src/jixia/debates/adk_simple_debate.py @@ -0,0 +1,82 @@ +#!/usr/bin/env python3 +# -*- coding: utf-8 -*- +""" +稷下学宫 ADK 简单论道测试 +实现智能体间的基本对话功能 +""" + +import os +from google.adk import Agent + +def create_debate_agents(): + """创建论道智能体""" + + # 铁拐李 - 逆向思维专家 + tie_guai_li = Agent( + name="铁拐李", + model="gemini-2.0-flash-exp" + ) + + # 吕洞宾 - 理性分析者 + lu_dong_bin = Agent( + name="吕洞宾", + model="gemini-2.0-flash-exp" + ) + + return tie_guai_li, lu_dong_bin + +def simple_debate_test(): + """简单论道测试""" + print("🎭 开始简单论道测试...") + + # 创建智能体 + tie_guai_li, lu_dong_bin = create_debate_agents() + + print("\n📋 论道主题: 人工智能对未来社会的影响") + print("\n🎯 开始论道...") + + try: + # 测试智能体创建 + print("\n✅ 智能体创建成功:") + print(f" - {tie_guai_li.name}: {tie_guai_li.model}") + print(f" - {lu_dong_bin.name}: {lu_dong_bin.model}") + + print("\n🎉 简单论道测试完成！") + print("\n📝 智能体基础功能验证成功") + + except Exception as e: + print(f"❌ 论道测试失败: {e}") + return False + + return True + +def main(): + """主函数""" + print("🚀 稷下学宫 ADK 简单论道系统") + + # 检查API密钥 + api_key = os.getenv('GOOGLE_API_KEY') + if not api_key: + print("❌ 未找到 GOOGLE_API_KEY 环境变量") + print("请使用: doppler run -- python src/jixia/debates/adk_simple_debate.py") + return + + print(f"✅ API密钥已配置") + + # 运行测试 + try: + result = simple_debate_test() + if result: + print("\n📝 测试结果: 成功") + print("\n🎯 下一步开发计划:") + print(" 1. 学习ADK的正确调用方式") + print(" 2. 实现智能体对话功能") + print(" 3. 扩展到八仙全员论道") + print(" 4. 集成实时数据源") + else: + print("\n❌ 测试失败") + except Exception as e: + print(f"❌ 运行失败: {e}") + +if __name__ == "__main__": + main() \ No newline at end of file diff --git a/src/jixia/debates/qczh_debate.py b/src/jixia/debates/qczh_debate.py new file mode 100644 index 0000000..eaafce9 --- /dev/null +++ b/src/jixia/debates/qczh_debate.py @@ -0,0 +1,165 @@ +#!/usr/bin/env python3 +# -*- coding: utf-8 -*- +""" +太公心易 - 起承转合辩论系统 +""" + +import json +from datetime import datetime +from typing import Dict, List, Any +from enum import Enum + +class DebateStage(Enum): + QI = "起" # 八仙按先天八卦顺序 + CHENG = "承" # 雁阵式承接 + ZHUAN = "转" # 自由辩论（36次handoff） + HE = "合" # 交替总结 + +class QiChengZhuanHeDebate: + """起承转合辩论系统""" + + def __init__(self): + # 八仙配置（先天八卦顺序） + self.baxian_sequence = ["吕洞宾", "何仙姑", "铁拐李", "汉钟离", "蓝采和", "张果老", "韩湘子", "曹国舅"] + + # 雁阵配置 + self.goose_formation = { + "positive": ["正1", "正2", "正3", "正4"], + "negative": ["反1", "反2", "反3", "反4"] + } + + # 交替总结顺序 + self.alternating_sequence = ["反1", "正1", "反2", "正2", "反3", "正3", "反4", "正4"] + + # 辩论状态 + self.current_stage = DebateStage.QI + self.stage_progress = 0 + self.total_handoffs = 0 + self.debate_history = [] + + # 阶段配置 + self.stage_configs = { + DebateStage.QI: {"max_progress": 8, "description": "八仙按先天八卦顺序"}, + DebateStage.CHENG: {"max_progress": 8, "description": "雁阵式承接"}, + DebateStage.ZHUAN: {"max_progress": 36, "description": "自由辩论"}, + DebateStage.HE: {"max_progress": 8, "description": "交替总结"} + } + + def get_current_speaker(self) -> str: + """获取当前发言者""" + if self.current_stage == DebateStage.QI: + return self.baxian_sequence[self.stage_progress % 8] + elif self.current_stage == DebateStage.CHENG: + if self.stage_progress < 4: + return self.goose_formation["positive"][self.stage_progress] + else: + return self.goose_formation["negative"][self.stage_progress - 4] + elif self.current_stage == DebateStage.ZHUAN: + # 简化的优先级算法 + speakers = self.goose_formation["positive"] + self.goose_formation["negative"] + return speakers[self.total_handoffs % 8] + elif self.current_stage == DebateStage.HE: + return self.alternating_sequence[self.stage_progress % 8] + + return "未知发言者" + + def advance_stage(self): + """推进辩论阶段""" + config = self.stage_configs[self.current_stage] + + if self.stage_progress >= config["max_progress"] - 1: + self._transition_to_next_stage() + else: + self.stage_progress += 1 + + def _transition_to_next_stage(self): + """转换到下一阶段""" + transitions = { + DebateStage.QI: DebateStage.CHENG, + DebateStage.CHENG: DebateStage.ZHUAN, + DebateStage.ZHUAN: DebateStage.HE, + DebateStage.HE: None + } + + next_stage = transitions[self.current_stage] + if next_stage: + self.current_stage = next_stage + self.stage_progress = 0 + print(f"🎭 辩论进入{next_stage.value}阶段") + else: + print("🎉 辩论结束！") + + def record_speech(self, speaker: str, message: str): + """记录发言""" + record = { + "timestamp": datetime.now().isoformat(), + "stage": self.current_stage.value, + "progress": self.stage_progress, + "speaker": speaker, + "message": message, + "handoffs": self.total_handoffs + } + + self.debate_history.append(record) + + if self.current_stage == DebateStage.ZHUAN: + self.total_handoffs += 1 + + def get_stage_info(self) -> Dict[str, Any]: + """获取阶段信息""" + config = self.stage_configs[self.current_stage] + return { + "stage": self.current_stage.value, + "progress": self.stage_progress + 1, + "max_progress": config["max_progress"], + "description": config["description"], + "current_speaker": self.get_current_speaker(), + "total_handoffs": self.total_handoffs + } + + def save_state(self, filename: str = "qczh_debate_state.json"): + """保存状态""" + state = { + "current_stage": self.current_stage.value, + "stage_progress": self.stage_progress, + "total_handoffs": self.total_handoffs, + "debate_history": self.debate_history + } + + with open(filename, 'w', encoding='utf-8') as f: + json.dump(state, f, ensure_ascii=False, indent=2) + + print(f"💾 辩论状态已保存到 {filename}") + +def main(): + """测试函数""" + print("🚀 起承转合辩论系统测试") + print("=" * 50) + + debate = QiChengZhuanHeDebate() + + # 测试各阶段 + test_messages = [ + "起：八仙按先天八卦顺序阐述观点", + "承：雁阵式承接，总体阐述+讥讽", + "转：自由辩论，36次handoff", + "合：交替总结，最终论证" + ] + + for i, message in enumerate(test_messages): + info = debate.get_stage_info() + speaker = debate.get_current_speaker() + + print(f"\n🎭 阶段: {info['stage']} ({info['progress']}/{info['max_progress']})") + print(f"🗣️ 发言者: {speaker}") + print(f"💬 消息: {message}") + + debate.record_speech(speaker, message) + debate.advance_stage() + + debate.save_state() + print("\n✅ 测试完成！") + +if __name__ == "__main__": + main() + diff --git a/src/jixia/debates/qi_cheng_zhuan_he_debate.py b/src/jixia/debates/qi_cheng_zhuan_he_debate.py new file mode 100644 index 0000000..278b502 --- /dev/null +++ b/src/jixia/debates/qi_cheng_zhuan_he_debate.py @@ -0,0 +1,341 @@ +#!/usr/bin/env python3 +# -*- coding: utf-8 -*- +""" +太公心易 - 起承转合辩论系统 +基于先天八卦的八仙辩论架构 +""" + +import asyncio +import json +from datetime import datetime +from typing import Dict, List, Any, Optional +from dataclasses import dataclass +from enum import Enum + +class DebateStage(Enum): + """辩论阶段枚举""" + QI = "起" # 八仙按先天八卦顺序 + CHENG = "承" # 雁阵式承接 + ZHUAN = "转" # 自由辩论（36次handoff） + HE = "合" # 交替总结 + +@dataclass +class Speaker: + """发言者数据类""" + name: str + role: str + team: str # "positive" or "negative" + bagua_position: Optional[int] = None # 八卦位置（0-7） + +@dataclass +class DebateContext: + """辩论上下文""" + current_stage: DebateStage + stage_progress: int + total_handoffs: int + current_speaker: Optional[str] = None + last_message: Optional[str] = None + debate_history: List[Dict] = None + +class QiChengZhuanHeDebateSystem: + """起承转合辩论系统""" + + def __init__(self): + # 八仙配置（按先天八卦顺序） + self.baxian_speakers = { + "吕洞宾": Speaker("吕洞宾", "剑仙投资顾问", "neutral", 0), # 乾 + "何仙姑": Speaker("何仙姑", "慈悲风控专家", "neutral", 1), # 兑 + "铁拐李": Speaker("铁拐李", "逆向思维专家", "neutral", 2), # 离 + "汉钟离": Speaker("汉钟离", "平衡协调者", "neutral", 3), # 震 + "蓝采和": Speaker("蓝采和", "创新思维者", "neutral", 4), # 巽 + "张果老": Speaker("张果老", "历史智慧者", "neutral", 5), # 坎 + "韩湘子": Speaker("韩湘子", "艺术感知者", "neutral", 6), # 艮 + "曹国舅": Speaker("曹国舅", "实务执行者", "neutral", 7) # 坤 + } + + # 雁阵队伍配置 + self.goose_formation = { + "positive": ["正1", "正2", "正3", "正4"], + "negative": ["反1", "反2", "反3", "反4"] + } + + # 辩论状态 + self.context = DebateContext( + current_stage=DebateStage.QI, + stage_progress=0, + total_handoffs=0, + debate_history=[] + ) + + # 阶段配置 + self.stage_configs = { + DebateStage.QI: { + "duration": "8-10分钟", + "max_progress": 8, # 八仙轮流发言 + "description": "八仙按先天八卦顺序阐述观点" + }, + DebateStage.CHENG: { + "duration": "8-10分钟", + "max_progress": 8, # 正反各4人 + "description": "雁阵式承接，总体阐述+讥讽" + }, + DebateStage.ZHUAN: { + "duration": "12-15分钟", + "max_progress": 36, # 36次handoff + "description": "自由辩论，优先级算法决定发言" + }, + DebateStage.HE: { + "duration": "8-10分钟", + "max_progress": 8, # 交替总结 + "description": "交替总结，最终论证" + } + } + + # 优先级算法 + self.priority_algorithm = PriorityAlgorithm() + + # 记忆系统 + self.memory_system = DebateMemorySystem() + + def get_current_speaker(self) -> str: + """获取当前发言者""" + stage = self.context.current_stage + progress = self.context.stage_progress + + if stage == DebateStage.QI: + return self._get_bagua_speaker(progress) + elif stage == DebateStage.CHENG: + return self._get_goose_formation_speaker(progress) + elif stage == DebateStage.ZHUAN: + return self._get_priority_speaker() + elif stage == DebateStage.HE: + return self._get_alternating_speaker(progress) + + return "未知发言者" + + def _get_bagua_speaker(self, progress: int) -> str: + """获取八卦顺序发言者""" + bagua_sequence = ["吕洞宾", "何仙姑", "铁拐李", "汉钟离", "蓝采和", "张果老", "韩湘子", "曹国舅"] + return bagua_sequence[progress % 8] + + def _get_goose_formation_speaker(self, progress: int) -> str: + """获取雁阵发言者""" + if progress < 4: + # 正方雁阵 + return self.goose_formation["positive"][progress] + else: + # 反方雁阵 + return self.goose_formation["negative"][progress - 4] + + def _get_priority_speaker(self) -> str: + """获取优先级发言者""" + return self.priority_algorithm.calculate_next_speaker(self.context) + + def _get_alternating_speaker(self, progress: int) -> str: + """获取交替总结发言者""" + alternating_sequence = ["反1", "正1", "反2", "正2", "反3", "正3", "反4", "正4"] + return alternating_sequence[progress % 8] + + def advance_stage(self): + """推进辩论阶段""" + current_config = self.stage_configs[self.context.current_stage] + + if self.context.stage_progress >= current_config["max_progress"] - 1: + # 当前阶段完成，进入下一阶段 + self._transition_to_next_stage() + else: + # 当前阶段继续 + self.context.stage_progress += 1 + + def _transition_to_next_stage(self): + """转换到下一阶段""" + stage_transitions = { + DebateStage.QI: DebateStage.CHENG, + DebateStage.CHENG: DebateStage.ZHUAN, + DebateStage.ZHUAN: DebateStage.HE, + DebateStage.HE: None # 辩论结束 + } + + next_stage = stage_transitions[self.context.current_stage] + if next_stage: + self.context.current_stage = next_stage + self.context.stage_progress = 0 + print(f"🎭 辩论进入{next_stage.value}阶段") + else: + print("🎉 辩论结束！") + + def record_speech(self, speaker: str, message: str): + """记录发言""" + speech_record = { + "timestamp": datetime.now().isoformat(), + "stage": self.context.current_stage.value, + "stage_progress": self.context.stage_progress, + "speaker": speaker, + "message": message, + "total_handoffs": self.context.total_handoffs + } + + self.context.debate_history.append(speech_record) + self.context.last_message = message + self.context.current_speaker = speaker + + # 更新记忆系统 + self.memory_system.store_speech(speaker, message, self.context) + + # 如果是转阶段，增加handoff计数 + if self.context.current_stage == DebateStage.ZHUAN: + self.context.total_handoffs += 1 + + def get_stage_info(self) -> Dict[str, Any]: + """获取当前阶段信息""" + stage = self.context.current_stage + config = self.stage_configs[stage] + + return { + "current_stage": stage.value, + "stage_progress": self.context.stage_progress, + "max_progress": config["max_progress"], + "description": config["description"], + "current_speaker": self.get_current_speaker(), + "total_handoffs": self.context.total_handoffs + } + + def save_debate_state(self, filename: str = "debate_state.json"): + """保存辩论状态""" + state_data = { + "context": { + "current_stage": self.context.current_stage.value, + "stage_progress": self.context.stage_progress, + "total_handoffs": self.context.total_handoffs, + "current_speaker": self.context.current_speaker, + "last_message": self.context.last_message + }, + "debate_history": self.context.debate_history, + "memory_data": self.memory_system.get_memory_data() + } + + with open(filename, 'w', encoding='utf-8') as f: + json.dump(state_data, f, ensure_ascii=False, indent=2) + + print(f"💾 辩论状态已保存到 {filename}") + +class PriorityAlgorithm: + """优先级算法""" + + def __init__(self): + self.speaker_weights = { + "rebuttal_urgency": 0.3, + "argument_strength": 0.25, + "time_pressure": 0.2, + "audience_reaction": 0.15, + "strategy_need": 0.1 + } + + def calculate_next_speaker(self, context: DebateContext) -> str: + """计算下一个发言者""" + # 简化的优先级算法 + available_speakers = ["正1", "正2", "正3", "正4", "反1", "反2", "反3", "反4"] + + # 基于当前上下文计算优先级 + priorities = {} + for speaker in available_speakers: + priority_score = self._calculate_speaker_priority(speaker, context) + priorities[speaker] = priority_score + + # 选择最高优先级发言者 + return max(priorities, key=priorities.get) + + def _calculate_speaker_priority(self, speaker: str, context: DebateContext) -> float: + """计算发言者优先级""" + # 简化的优先级计算 + base_score = 0.5 + + # 根据发言者角色调整 + if "正" in speaker: + base_score += 0.1 + if "反" in speaker: + base_score += 0.1 + + # 根据handoff次数调整 + if context.total_handoffs % 2 == 0: + base_score += 0.2 + + return base_score + +class DebateMemorySystem: + """辩论记忆系统""" + + def __init__(self): + self.speaker_memories = {} + self.debate_memories = [] + + def store_speech(self, speaker: str, message: str, context: DebateContext): + """存储发言记忆""" + if speaker not in self.speaker_memories: + self.speaker_memories[speaker] = [] + + memory_entry = { + "timestamp": datetime.now().isoformat(), + "stage": context.current_stage.value, + "message": message, + "context": { + "stage_progress": context.stage_progress, + "total_handoffs": context.total_handoffs + } + } + + self.speaker_memories[speaker].append(memory_entry) + self.debate_memories.append(memory_entry) + + def get_speaker_memory(self, speaker: str, limit: int = 5) -> List[Dict]: + """获取发言者记忆""" + if speaker in self.speaker_memories: + return self.speaker_memories[speaker][-limit:] + return [] + + def get_memory_data(self) -> Dict[str, Any]: + """获取记忆数据""" + return { + "speaker_memories": self.speaker_memories, + "debate_memories": self.debate_memories + } + +def main(): + """主函数 - 测试起承转合辩论系统""" + print("🚀 太公心易 - 起承转合辩论系统") + print("=" * 60) + + # 创建辩论系统 + debate_system = QiChengZhuanHeDebateSystem() + + # 测试各阶段 + test_messages = [ + "起：八仙按先天八卦顺序阐述观点", + "承：雁阵式承接，总体阐述+讥讽", + "转：自由辩论，36次handoff", + "合：交替总结，最终论证" + ] + + for i, message in enumerate(test_messages): + stage_info = debate_system.get_stage_info() + current_speaker = debate_system.get_current_speaker() + + print(f"\n🎭 当前阶段: {stage_info['current_stage']}") + print(f"📊 进度: {stage_info['stage_progress'] + 1}/{stage_info['max_progress']}") + print(f"🗣️ 发言者: {current_speaker}") + print(f"💬 消息: {message}") + + # 记录发言 + debate_system.record_speech(current_speaker, message) + + # 推进阶段 + debate_system.advance_stage() + + # 保存状态 + debate_system.save_debate_state() + + print("\n✅ 起承转合辩论系统测试完成！") + +if __name__ == "__main__": + main() + diff --git a/src/jixia/memory/base_memory_bank.py b/src/jixia/memory/base_memory_bank.py new file mode 100644 index 0000000..9244514 --- /dev/null +++ b/src/jixia/memory/base_memory_bank.py @@ -0,0 +1,39 @@ +#!/usr/bin/env python3 +""" +通用记忆银行抽象，便于插入不同后端（Vertex、Cloudflare AutoRAG等） +""" +from __future__ import annotations + +from typing import Dict, List, Any, Optional, Protocol, runtime_checkable + + +@runtime_checkable +class MemoryBankProtocol(Protocol): + async def create_memory_bank(self, agent_name: str, display_name: Optional[str] = None) -> str: ... + + async def add_memory( + self, + agent_name: str, + content: str, + memory_type: str = "conversation", + debate_topic: str = "", + metadata: Optional[Dict[str, Any]] = None, + ) -> str: ... + + async def search_memories( + self, + agent_name: str, + query: str, + memory_type: Optional[str] = None, + limit: int = 10, + ) -> List[Dict[str, Any]]: ... + + async def get_agent_context(self, agent_name: str, debate_topic: str) -> str: ... + + async def save_debate_session( + self, + debate_topic: str, + participants: List[str], + conversation_history: List[Dict[str, str]], + outcomes: Optional[Dict[str, Any]] = None, + ) -> None: ... diff --git a/src/jixia/memory/factory.py b/src/jixia/memory/factory.py new file mode 100644 index 0000000..2f76cc5 --- /dev/null +++ b/src/jixia/memory/factory.py @@ -0,0 +1,37 @@ +#!/usr/bin/env python3 +""" +记忆银行工厂：根据配置创建 Vertex 实现 +""" +from __future__ import annotations + +import os +from typing import Optional + +from .base_memory_bank import MemoryBankProtocol +from .vertex_memory_bank import VertexMemoryBank + + +def get_memory_backend(prefer: Optional[str] = None) -> MemoryBankProtocol: + """ + 根据环境变量选择记忆后端： + - JIXIA_MEMORY_BACKEND=vertex (默认) + - 如果未设置，默认使用 Vertex + """ + # 从环境变量读取后端选择，默认为 vertex + backend = os.getenv("JIXIA_MEMORY_BACKEND", "vertex").lower() + + if prefer: + backend = prefer.lower() + + if backend != "vertex": + raise ValueError(f"不支持的记忆后端: {backend}，当前只支持 'vertex'") + + # Vertex 作为唯一后端 + try: + mem = VertexMemoryBank.from_config() + return mem + except Exception as e: + # 不可用时抛错 + raise RuntimeError( + "未能创建 Vertex 记忆后端：请配置 Vertex (GOOGLE_*) 环境变量" + ) from e diff --git a/src/jixia/memory/vertex_memory_bank.py b/src/jixia/memory/vertex_memory_bank.py new file mode 100644 index 0000000..b43c603 --- /dev/null +++ b/src/jixia/memory/vertex_memory_bank.py @@ -0,0 +1,463 @@ +#!/usr/bin/env python3 +""" +Vertex AI Memory Bank 集成模块 +为稷下学宫AI辩论系统提供记忆银行功能 +""" + +import os +from typing import Dict, List, Optional, Any +from dataclasses import dataclass +from datetime import datetime +import json + +try: + from google.cloud import aiplatform + # Memory Bank 功能可能还在预览版中，先使用基础功能 + VERTEX_AI_AVAILABLE = True +except ImportError: + VERTEX_AI_AVAILABLE = False + print("⚠️ Google Cloud AI Platform 未安装，Memory Bank功能不可用") + print("安装命令: pip install google-cloud-aiplatform") + +from config.doppler_config import get_google_genai_config + + +@dataclass +class MemoryEntry: + """记忆条目数据结构""" + content: str + metadata: Dict[str, Any] + timestamp: datetime + agent_name: str + debate_topic: str + memory_type: str # "conversation", "preference", "knowledge", "strategy" + + +class VertexMemoryBank: + """ + Vertex AI Memory Bank 管理器 + 为八仙辩论系统提供智能记忆功能 + """ + + def __init__(self, project_id: str, location: str = "us-central1"): + """ + 初始化Memory Bank + + Args: + project_id: Google Cloud项目ID + location: 部署区域 + """ + if not VERTEX_AI_AVAILABLE: + print("⚠️ Google Cloud AI Platform 未安装，使用本地模拟模式") + # 不抛出异常，允许使用本地模拟模式 + + self.project_id = project_id + self.location = location + self.memory_banks = {} # 存储不同智能体的记忆银行 + self.local_memories = {} # 本地记忆存储 (临时方案) + + # 初始化AI Platform + try: + aiplatform.init(project=project_id, location=location) + print(f"✅ Vertex AI 初始化成功: {project_id} @ {location}") + except Exception as e: + print(f"⚠️ Vertex AI 初始化失败，使用本地模拟模式: {e}") + + # 八仙智能体名称映射 + self.baxian_agents = { + "tieguaili": "铁拐李", + "hanzhongli": "汉钟离", + "zhangguolao": "张果老", + "lancaihe": "蓝采和", + "hexiangu": "何仙姑", + "lvdongbin": "吕洞宾", + "hanxiangzi": "韩湘子", + "caoguojiu": "曹国舅" + } + + @classmethod + def from_config(cls) -> 'VertexMemoryBank': + """ + 从配置创建Memory Bank实例 + + Returns: + VertexMemoryBank实例 + """ + config = get_google_genai_config() + project_id = config.get('project_id') + location = config.get('location', 'us-central1') + + if not project_id: + raise ValueError("Google Cloud Project ID 未配置，请设置 GOOGLE_CLOUD_PROJECT_ID") + + return cls(project_id=project_id, location=location) + + async def create_memory_bank(self, agent_name: str, display_name: str = None) -> str: + """ + 为指定智能体创建记忆银行 + + Args: + agent_name: 智能体名称 (如 "tieguaili") + display_name: 显示名称 (如 "铁拐李的记忆银行") + + Returns: + 记忆银行ID + """ + if not display_name: + chinese_name = self.baxian_agents.get(agent_name, agent_name) + display_name = f"{chinese_name}的记忆银行" + + try: + # 使用本地存储模拟记忆银行 (临时方案) + memory_bank_id = f"memory_bank_{agent_name}_{self.project_id}" + + # 初始化本地记忆存储 + if agent_name not in self.local_memories: + self.local_memories[agent_name] = [] + + self.memory_banks[agent_name] = memory_bank_id + print(f"✅ 为 {display_name} 创建记忆银行: {memory_bank_id}") + + return memory_bank_id + + except Exception as e: + print(f"❌ 创建记忆银行失败: {e}") + raise + + async def add_memory(self, + agent_name: str, + content: str, + memory_type: str = "conversation", + debate_topic: str = "", + metadata: Dict[str, Any] = None) -> str: + """ + 添加记忆到指定智能体的记忆银行 + + Args: + agent_name: 智能体名称 + content: 记忆内容 + memory_type: 记忆类型 ("conversation", "preference", "knowledge", "strategy") + debate_topic: 辩论主题 + metadata: 额外元数据 + + Returns: + 记忆ID + """ + if agent_name not in self.memory_banks: + await self.create_memory_bank(agent_name) + + if metadata is None: + metadata = {} + + # 构建记忆条目 + memory_entry = MemoryEntry( + content=content, + metadata={ + **metadata, + "agent_name": agent_name, + "chinese_name": self.baxian_agents.get(agent_name, agent_name), + "memory_type": memory_type, + "debate_topic": debate_topic, + "system": "jixia_academy" + }, + timestamp=datetime.now(), + agent_name=agent_name, + debate_topic=debate_topic, + memory_type=memory_type + ) + + try: + # 使用本地存储添加记忆 (临时方案) + memory_id = f"memory_{agent_name}_{len(self.local_memories[agent_name])}" + + # 添加到本地存储 + memory_data = { + "id": memory_id, + "content": content, + "metadata": memory_entry.metadata, + "timestamp": memory_entry.timestamp.isoformat(), + "memory_type": memory_type, + "debate_topic": debate_topic + } + + self.local_memories[agent_name].append(memory_data) + + print(f"✅ 为 {self.baxian_agents.get(agent_name)} 添加记忆: {memory_type}") + return memory_id + + except Exception as e: + print(f"❌ 添加记忆失败: {e}") + raise + + async def search_memories(self, + agent_name: str, + query: str, + memory_type: str = None, + limit: int = 10) -> List[Dict[str, Any]]: + """ + 搜索智能体的相关记忆 + + Args: + agent_name: 智能体名称 + query: 搜索查询 + memory_type: 记忆类型过滤 + limit: 返回结果数量限制 + + Returns: + 相关记忆列表 + """ + if agent_name not in self.memory_banks: + return [] + + try: + # 使用本地存储搜索记忆 (临时方案) + if agent_name not in self.local_memories: + return [] + + memories = self.local_memories[agent_name] + results = [] + + # 简单的文本匹配搜索 + query_lower = query.lower() + + for memory in memories: + # 检查记忆类型过滤 + if memory_type and memory.get("memory_type") != memory_type: + continue + + # 检查内容匹配 + content_lower = memory["content"].lower() + debate_topic_lower = memory.get("debate_topic", "").lower() + + # 在内容或辩论主题中搜索 + if query_lower in content_lower or query_lower in debate_topic_lower: + # 计算简单的相关性分数 + content_matches = content_lower.count(query_lower) + topic_matches = debate_topic_lower.count(query_lower) + total_words = len(content_lower.split()) + len(debate_topic_lower.split()) + + relevance_score = (content_matches + topic_matches) / max(total_words, 1) + + results.append({ + "content": memory["content"], + "metadata": memory["metadata"], + "relevance_score": relevance_score + }) + + # 按相关性排序并限制结果数量 + results.sort(key=lambda x: x["relevance_score"], reverse=True) + return results[:limit] + + except Exception as e: + print(f"❌ 搜索记忆失败: {e}") + return [] + + async def get_agent_context(self, agent_name: str, debate_topic: str) -> str: + """ + 获取智能体在特定辩论主题下的上下文记忆 + + Args: + agent_name: 智能体名称 + debate_topic: 辩论主题 + + Returns: + 格式化的上下文字符串 + """ + # 搜索相关记忆 + conversation_memories = await self.search_memories( + agent_name, debate_topic, "conversation", limit=5 + ) + preference_memories = await self.search_memories( + agent_name, debate_topic, "preference", limit=3 + ) + strategy_memories = await self.search_memories( + agent_name, debate_topic, "strategy", limit=3 + ) + + # 构建上下文 + context_parts = [] + + if conversation_memories: + context_parts.append("## 历史对话记忆") + for mem in conversation_memories: + context_parts.append(f"- {mem['content']}") + + if preference_memories: + context_parts.append("\n## 偏好记忆") + for mem in preference_memories: + context_parts.append(f"- {mem['content']}") + + if strategy_memories: + context_parts.append("\n## 策略记忆") + for mem in strategy_memories: + context_parts.append(f"- {mem['content']}") + + chinese_name = self.baxian_agents.get(agent_name, agent_name) + if context_parts: + return f"# {chinese_name}的记忆上下文\n\n" + "\n".join(context_parts) + else: + return f"# {chinese_name}的记忆上下文\n\n暂无相关记忆。" + + async def save_debate_session(self, + debate_topic: str, + participants: List[str], + conversation_history: List[Dict[str, str]], + outcomes: Dict[str, Any] = None) -> None: + """ + 保存完整的辩论会话到各参与者的记忆银行 + + Args: + debate_topic: 辩论主题 + participants: 参与者列表 + conversation_history: 对话历史 + outcomes: 辩论结果和洞察 + """ + for agent_name in participants: + if agent_name not in self.baxian_agents: + continue + + # 保存对话历史 + conversation_summary = self._summarize_conversation( + conversation_history, agent_name + ) + await self.add_memory( + agent_name=agent_name, + content=conversation_summary, + memory_type="conversation", + debate_topic=debate_topic, + metadata={ + "participants": participants, + "session_length": len(conversation_history) + } + ) + + # 保存策略洞察 + if outcomes: + strategy_insight = self._extract_strategy_insight( + outcomes, agent_name + ) + if strategy_insight: + await self.add_memory( + agent_name=agent_name, + content=strategy_insight, + memory_type="strategy", + debate_topic=debate_topic, + metadata={"session_outcome": outcomes} + ) + + def _summarize_conversation(self, + conversation_history: List[Dict[str, str]], + agent_name: str) -> str: + """ + 为特定智能体总结对话历史 + + Args: + conversation_history: 对话历史 + agent_name: 智能体名称 + + Returns: + 对话总结 + """ + agent_messages = [ + msg for msg in conversation_history + if msg.get("agent") == agent_name + ] + + if not agent_messages: + return "本次辩论中未发言" + + chinese_name = self.baxian_agents.get(agent_name, agent_name) + summary = f"{chinese_name}在本次辩论中的主要观点：\n" + + for i, msg in enumerate(agent_messages[:3], 1): # 只取前3条主要观点 + summary += f"{i}. {msg.get('content', '')[:100]}...\n" + + return summary + + def _extract_strategy_insight(self, + outcomes: Dict[str, Any], + agent_name: str) -> Optional[str]: + """ + 从辩论结果中提取策略洞察 + + Args: + outcomes: 辩论结果 + agent_name: 智能体名称 + + Returns: + 策略洞察或None + """ + # 这里可以根据实际的outcomes结构来提取洞察 + # 暂时返回一个简单的示例 + chinese_name = self.baxian_agents.get(agent_name, agent_name) + + if "winner" in outcomes and outcomes["winner"] == agent_name: + return f"{chinese_name}在本次辩论中获胜，其论证策略值得保持。" + elif "insights" in outcomes and agent_name in outcomes["insights"]: + return outcomes["insights"][agent_name] + + return None + + +# 便捷函数 +async def initialize_baxian_memory_banks(project_id: str, location: str = "us-central1") -> VertexMemoryBank: + """ + 初始化所有八仙智能体的记忆银行 + + Args: + project_id: Google Cloud项目ID + location: 部署区域 + + Returns: + 配置好的VertexMemoryBank实例 + """ + memory_bank = VertexMemoryBank(project_id, location) + + print("🏛️ 正在为稷下学宫八仙创建记忆银行...") + + for agent_key, chinese_name in memory_bank.baxian_agents.items(): + try: + await memory_bank.create_memory_bank(agent_key) + except Exception as e: + print(f"⚠️ 创建 {chinese_name} 记忆银行时出错: {e}") + + print("✅ 八仙记忆银行初始化完成") + return memory_bank + + +if __name__ == "__main__": + import asyncio + + async def test_memory_bank(): + """测试Memory Bank功能""" + try: + # 从配置创建Memory Bank + memory_bank = VertexMemoryBank.from_config() + + # 测试创建记忆银行 + await memory_bank.create_memory_bank("tieguaili") + + # 测试添加记忆 + await memory_bank.add_memory( + agent_name="tieguaili", + content="在讨论NVIDIA股票时，我倾向于逆向思维，关注潜在风险。", + memory_type="preference", + debate_topic="NVIDIA投资分析" + ) + + # 测试搜索记忆 + results = await memory_bank.search_memories( + agent_name="tieguaili", + query="NVIDIA", + limit=5 + ) + + print(f"搜索结果: {len(results)} 条记忆") + for result in results: + print(f"- {result['content']}") + + except Exception as e: + print(f"❌ 测试失败: {e}") + + # 运行测试 + asyncio.run(test_memory_bank()) diff --git a/test-api-example.js b/test-api-example.js new file mode 100644 index 0000000..ff87daa --- /dev/null +++ b/test-api-example.js @@ -0,0 +1,299 @@ +// API 测试示例脚本 +// 演示如何使用 Hyperdrive API 进行 CRUD 操作 + +const API_BASE_URL = 'https://hyperdrive-neondb-test..workers.dev'; +const API_KEY = 'your-api-key'; // 可选，如果设置了 API_SECRET + +// 通用请求函数 +async function apiRequest(endpoint, options = {}) { + const url = `${API_BASE_URL}${endpoint}`; + const headers = { + 'Content-Type': 'application/json', + ...(API_KEY && { 'X-API-Key': API_KEY }), + ...options.headers + }; + + try { + const response = await fetch(url, { + ...options, + headers + }); + + const data = await response.json(); + + if (!response.ok) { + throw new Error(`API Error: ${data.message || response.statusText}`); + } + + return data; + } catch (error) { + console.error(`Request failed for ${endpoint}:`, error.message); + throw error; + } +} + +// API 测试函数 +class ApiTester { + static async testHealthCheck() { + console.log('\n🏥 Testing health check...'); + try { + const result = await apiRequest('/health'); + console.log('✅ Health check passed:', result.data); + return true; + } catch (error) { + console.log('❌ Health check failed:', error.message); + return false; + } + } + + static async initializeDatabase() { + console.log('\n🗄️ Initializing database...'); + try { + const result = await apiRequest('/init', { method: 'POST' }); + console.log('✅ Database initialized:', result.message); + return true; + } catch (error) { + console.log('❌ Database initialization failed:', error.message); + return false; + } + } + + static async createUser(name, email) { + console.log(`\n👤 Creating user: ${name} (${email})...`); + try { + const result = await apiRequest('/users', { + method: 'POST', + body: JSON.stringify({ name, email }) + }); + console.log('✅ User created:', result.data); + return result.data; + } catch (error) { + console.log('❌ User creation failed:', error.message); + return null; + } + } + + static async getUsers(page = 1, limit = 10, search = null) { + console.log(`\n📋 Getting users (page ${page}, limit ${limit}${search ? `, search: ${search}` : ''})...`); + try { + let endpoint = `/users?page=${page}&limit=${limit}`; + if (search) endpoint += `&search=${encodeURIComponent(search)}`; + + const result = await apiRequest(endpoint); + console.log('✅ Users retrieved:', { + count: result.data.length, + total: result.meta.total, + users: result.data.map(u => `${u.name} (${u.email})`) + }); + return result; + } catch (error) { + console.log('❌ Failed to get users:', error.message); + return null; + } + } + + static async getUserById(id) { + console.log(`\n🔍 Getting user by ID: ${id}...`); + try { + const result = await apiRequest(`/users/${id}`); + console.log('✅ User found:', result.data); + return result.data; + } catch (error) { + console.log('❌ Failed to get user:', error.message); + return null; + } + } + + static async updateUser(id, updates) { + console.log(`\n✏️ Updating user ${id}:`, updates); + try { + const result = await apiRequest(`/users/${id}`, { + method: 'PUT', + body: JSON.stringify(updates) + }); + console.log('✅ User updated:', result.data); + return result.data; + } catch (error) { + console.log('❌ Failed to update user:', error.message); + return null; + } + } + + static async deleteUser(id) { + console.log(`\n🗑️ Deleting user ${id}...`); + try { + const result = await apiRequest(`/users/${id}`, { method: 'DELETE' }); + console.log('✅ User deleted:', result.message); + return true; + } catch (error) { + console.log('❌ Failed to delete user:', error.message); + return false; + } + } + + static async getApiDocs() { + console.log('\n📚 Getting API documentation...'); + try { + const result = await apiRequest('/docs'); + console.log('✅ API Documentation:'); + console.log('Endpoints:', result.data.endpoints); + console.log('Authentication:', result.data.authentication); + console.log('Examples:', result.data.examples); + return result.data; + } catch (error) { + console.log('❌ Failed to get API docs:', error.message); + return null; + } + } +} + +// 完整的测试流程 +async function runFullTest() { + console.log('🚀 Starting Hyperdrive API Test Suite'); + console.log('====================================='); + + // 1. 健康检查 + const healthOk = await ApiTester.testHealthCheck(); + if (!healthOk) { + console.log('\n❌ Health check failed. Please check your deployment.'); + return; + } + + // 2. 获取 API 文档 + await ApiTester.getApiDocs(); + + // 3. 初始化数据库 + await ApiTester.initializeDatabase(); + + // 4. 创建测试用户 + const user1 = await ApiTester.createUser('张三', 'zhangsan@example.com'); + const user2 = await ApiTester.createUser('李四', 'lisi@example.com'); + const user3 = await ApiTester.createUser('王五', 'wangwu@example.com'); + + if (!user1 || !user2 || !user3) { + console.log('\n❌ Failed to create test users.'); + return; + } + + // 5. 获取用户列表 + await ApiTester.getUsers(); + + // 6. 搜索用户 + await ApiTester.getUsers(1, 10, '张'); + + // 7. 获取单个用户 + await ApiTester.getUserById(user1.id); + + // 8. 更新用户 + await ApiTester.updateUser(user1.id, { + name: '张三丰', + email: 'zhangsanfeng@example.com' + }); + + // 9. 验证更新 + await ApiTester.getUserById(user1.id); + + // 10. 分页测试 + await ApiTester.getUsers(1, 2); // 第一页，每页2条 + await ApiTester.getUsers(2, 2); // 第二页，每页2条 + + // 11. 删除用户 + await ApiTester.deleteUser(user3.id); + + // 12. 验证删除 + await ApiTester.getUserById(user3.id); // 应该返回 404 + + // 13. 最终用户列表 + await ApiTester.getUsers(); + + console.log('\n🎉 API Test Suite Completed!'); + console.log('============================'); +} + +// 性能测试 +async function performanceTest() { + console.log('\n⚡ Performance Test'); + console.log('=================='); + + const startTime = Date.now(); + const promises = []; + + // 并发创建10个用户 + for (let i = 0; i < 10; i++) { + promises.push( + ApiTester.createUser(`测试用户${i}`, `test${i}@example.com`) + ); + } + + try { + const results = await Promise.all(promises); + const endTime = Date.now(); + const duration = endTime - startTime; + + console.log(`✅ Created ${results.filter(r => r).length} users in ${duration}ms`); + console.log(`📊 Average: ${(duration / 10).toFixed(2)}ms per user`); + + // 清理测试数据 + console.log('\n🧹 Cleaning up test data...'); + for (const user of results.filter(r => r)) { + await ApiTester.deleteUser(user.id); + } + + } catch (error) { + console.log('❌ Performance test failed:', error.message); + } +} + +// 错误处理测试 +async function errorHandlingTest() { + console.log('\n🚨 Error Handling Test'); + console.log('======================'); + + // 测试无效数据 + console.log('\n Testing invalid user data...'); + await ApiTester.createUser('', 'invalid-email'); // 应该失败 + + // 测试不存在的用户 + console.log('\n Testing non-existent user...'); + await ApiTester.getUserById(99999); // 应该返回 404 + + // 测试无效的更新 + console.log('\n Testing invalid update...'); + await ApiTester.updateUser(99999, { name: 'Test' }); // 应该返回 404 +} + +// 主函数 +async function main() { + console.log('请确保已经部署了 Worker 并更新了 API_BASE_URL'); + console.log('如果设置了 API_SECRET，请更新 API_KEY 变量\n'); + + try { + await runFullTest(); + await performanceTest(); + await errorHandlingTest(); + } catch (error) { + console.error('\n💥 Test suite failed:', error.message); + } +} + +// 如果直接运行此脚本 +if (typeof window === 'undefined') { + // Node.js 环境 + const fetch = require('node-fetch'); + global.fetch = fetch; + main(); +} else { + // 浏览器环境 + console.log('在浏览器控制台中运行: main()'); +} + +// 导出函数供其他模块使用 +if (typeof module !== 'undefined' && module.exports) { + module.exports = { + ApiTester, + runFullTest, + performanceTest, + errorHandlingTest, + main + }; +} \ No newline at end of file diff --git a/test-hyperdrive-remote.js b/test-hyperdrive-remote.js new file mode 100644 index 0000000..03954e5 --- /dev/null +++ b/test-hyperdrive-remote.js @@ -0,0 +1,79 @@ +// Test script to validate Hyperdrive configuration for remote deployment +// This script helps test the configuration without local PostgreSQL + +const { execSync } = require('child_process'); +const fs = require('fs'); + +console.log('🚀 Testing Hyperdrive Configuration for Remote Deployment'); +console.log('======================================================'); + +try { + // Check wrangler configuration + console.log('\n📋 Validating wrangler.toml...'); + + const wranglerContent = fs.readFileSync('wrangler.toml', 'utf8'); + console.log('✅ wrangler.toml loaded successfully'); + + // Validate configuration syntax + try { + execSync('wrangler config validate', { stdio: 'pipe' }); + console.log('✅ wrangler.toml syntax is valid'); + } catch (error) { + console.log('⚠️ Configuration validation warning (this is normal for Hyperdrive)'); + } + + // Check if we can authenticate with Cloudflare + console.log('\n🔐 Checking Cloudflare authentication...'); + try { + const whoami = execSync('wrangler whoami', { encoding: 'utf8' }); + console.log('✅ Authenticated with Cloudflare'); + console.log(` ${whoami.trim()}`); + } catch (error) { + console.log('❌ Not authenticated with Cloudflare'); + console.log(' Run: wrangler login'); + return; + } + + // List Hyperdrive configurations + console.log('\n🔗 Checking Hyperdrive configurations...'); + try { + const hyperdrives = execSync('wrangler hyperdrive list', { encoding: 'utf8' }); + console.log('✅ Hyperdrive configurations:'); + console.log(hyperdrives); + } catch (error) { + console.log('⚠️ Could not list Hyperdrive configurations'); + console.log(' Error:', error.message); + } + + // Check specific Hyperdrive + console.log('\n🎯 Checking specific Hyperdrive ID...'); + try { + const hyperdriveInfo = execSync('wrangler hyperdrive get ef43924d89064cddabfaccf06aadfab6', { encoding: 'utf8' }); + console.log('✅ Hyperdrive configuration found:'); + console.log(hyperdriveInfo); + } catch (error) { + console.log('❌ Could not find Hyperdrive configuration'); + console.log(' Error:', error.message); + console.log(' Make sure the Hyperdrive ID is correct and exists in your account'); + } + + console.log('\n📝 Configuration Summary:'); + console.log(' - Worker Name: hyperdrive-neondb-test'); + console.log(' - Hyperdrive ID: ef43924d89064cddabfaccf06aadfab6'); + console.log(' - Binding: HYPERDRIVE'); + console.log(' - Database Type: NeonDB (PostgreSQL)'); + + console.log('\n🚀 Deployment Commands:'); + console.log(' 1. Deploy to production: wrangler deploy'); + console.log(' 2. Test endpoints after deployment:'); + console.log(' - https://hyperdrive-neondb-test..workers.dev/test-connection'); + console.log(' - https://hyperdrive-neondb-test..workers.dev/test-query'); + + console.log('\n💡 Tips:'); + console.log(' - Hyperdrive provides connection pooling and caching for your database'); + console.log(' - It reduces latency and improves performance for database queries'); + console.log(' - The worker will automatically use the Hyperdrive connection in production'); + +} catch (error) { + console.error('❌ Error during testing:', error.message); +} \ No newline at end of file diff --git a/test-hyperdrive.js b/test-hyperdrive.js new file mode 100644 index 0000000..349a2c4 --- /dev/null +++ b/test-hyperdrive.js @@ -0,0 +1,93 @@ +// Simple test script for Hyperdrive configuration +// This script helps verify the wrangler.toml configuration + +console.log('🚀 Hyperdrive NeonDB Test Configuration'); +console.log('====================================='); + +// Check if wrangler.toml exists and has correct configuration +const fs = require('fs'); +const path = require('path'); + +try { + const wranglerPath = path.join(__dirname, 'wrangler.toml'); + + if (fs.existsSync(wranglerPath)) { + console.log('✅ wrangler.toml found'); + + const content = fs.readFileSync(wranglerPath, 'utf8'); + + // Check for Hyperdrive configuration + if (content.includes('hyperdrive')) { + console.log('✅ Hyperdrive configuration found'); + } else { + console.log('❌ Hyperdrive configuration missing'); + } + + // Check for binding + if (content.includes('binding = "HYPERDRIVE"')) { + console.log('✅ HYPERDRIVE binding configured'); + } else { + console.log('❌ HYPERDRIVE binding missing'); + } + + // Check for Hyperdrive ID + if (content.includes('ef43924d89064cddabfaccf06aadfab6')) { + console.log('✅ Hyperdrive ID configured'); + } else { + console.log('❌ Hyperdrive ID missing'); + } + + // Check for nodejs_compat + if (content.includes('nodejs_compat')) { + console.log('✅ nodejs_compat flag enabled'); + } else { + console.log('❌ nodejs_compat flag missing'); + } + + } else { + console.log('❌ wrangler.toml not found'); + } + + // Check if src/index.ts exists + const indexPath = path.join(__dirname, 'src', 'index.ts'); + if (fs.existsSync(indexPath)) { + console.log('✅ src/index.ts found'); + } else { + console.log('❌ src/index.ts missing'); + } + + // Check if package.json exists + const packagePath = path.join(__dirname, 'package.json'); + if (fs.existsSync(packagePath)) { + console.log('✅ package.json found'); + + const packageContent = JSON.parse(fs.readFileSync(packagePath, 'utf8')); + + // Check for required dependencies + if (packageContent.dependencies && packageContent.dependencies.pg) { + console.log('✅ pg dependency configured'); + } else { + console.log('❌ pg dependency missing'); + } + + if (packageContent.devDependencies && packageContent.devDependencies['@cloudflare/workers-types']) { + console.log('✅ Cloudflare Workers types configured'); + } else { + console.log('❌ Cloudflare Workers types missing'); + } + } + + console.log('\n📋 Next Steps:'); + console.log('1. Run: wrangler dev --local (for local testing)'); + console.log('2. Run: wrangler dev (for remote testing with Hyperdrive)'); + console.log('3. Test endpoints:'); + console.log(' - http://localhost:8787/test-connection'); + console.log(' - http://localhost:8787/test-query'); + console.log('\n🔧 Hyperdrive Configuration:'); + console.log(' - Hyperdrive ID: ef43924d89064cddabfaccf06aadfab6'); + console.log(' - Binding: HYPERDRIVE'); + console.log(' - Database: NeonDB (PostgreSQL)'); + +} catch (error) { + console.error('❌ Error checking configuration:', error.message); +} \ No newline at end of file diff --git a/test-shushu-api.sh b/test-shushu-api.sh new file mode 100755 index 0000000..bf49722 --- /dev/null +++ b/test-shushu-api.sh @@ -0,0 +1,67 @@ +#!/bin/bash + +# 术数书 API 测试脚本 +# 使用 curl 命令测试 Hyperdrive + NeonDB 术数书查询系统 + +API_BASE="https://hyperdrive.seekkey.tech" + +echo "🚀 术数书 Hyperdrive API 测试" +echo "================================" + +# 测试连接 +echo "" +echo "🔗 测试数据库连接..." +curl -s "$API_BASE/test-connection" | jq -r '.message // .error // "连接测试完成"' + +# 查询表结构 +echo "" +echo "📋 查询数据库表结构..." +echo "发现的表:" +curl -s "$API_BASE/query-tables" | jq -r '.tables[]? | "- \(.table_name) (\(.table_schema))"' + +# 获取术数书统计 +echo "" +echo "📊 术数书统计信息..." +curl -s "$API_BASE/shushu-stats" | jq -r '.existing_tables[]? | "- \(.table_name): \(.record_count) 条记录"' + +# 查询术数书内容 +echo "" +echo "📚 查询术数书内容 (前3条)..." +echo "书籍信息:" +curl -s "$API_BASE/query-shushu?limit=3" | jq -r '.data[]? | "- ID: \(.id), 标题: \(.title), 作者: \(.author), 类别: \(.category)"' + +# 搜索功能测试 +echo "" +echo "🔍 搜索测试..." +echo "搜索关键词: 易经" +curl -s "$API_BASE/search-shushu?q=易经&limit=2" | jq -r '.total_matches // 0 | "找到 \(.) 条匹配记录"' + +echo "搜索关键词: 八卦" +curl -s "$API_BASE/search-shushu?q=八卦&limit=2" | jq -r '.total_matches // 0 | "找到 \(.) 条匹配记录"' + +echo "搜索关键词: 面相" +curl -s "$API_BASE/search-shushu?q=面相&limit=2" | jq -r '.total_matches // 0 | "找到 \(.) 条匹配记录"' + +# 性能测试 +echo "" +echo "⚡ 性能测试..." +echo "测试查询响应时间:" +time curl -s "$API_BASE/query-shushu?limit=1" > /dev/null + +echo "" +echo "✅ API 测试完成！" +echo "" +echo "📖 可用端点:" +echo "- GET $API_BASE/ - 系统信息" +echo "- GET $API_BASE/test-connection - 测试连接" +echo "- GET $API_BASE/query-tables - 查询表结构" +echo "- GET $API_BASE/query-shushu?limit=N - 查询术数书" +echo "- GET $API_BASE/search-shushu?q=keyword&limit=N - 搜索术数书" +echo "- GET $API_BASE/shushu-stats - 统计信息" +echo "" +echo "🎯 与 AutoRAG 对比优势:" +echo "- ✅ 毫秒级响应 (Hyperdrive 边缘缓存)" +echo "- ✅ 精确查询 (SQL vs 向量相似性)" +echo "- ✅ 实时数据 (直连数据库)" +echo "- ✅ 成本优化 (连接池 + 缓存)" +echo "- ✅ 全球分布 (Cloudflare 边缘网络)" \ No newline at end of file diff --git a/test_alpha_vantage_meta.py b/tests/test_alpha_vantage_meta.py similarity index 100% rename from test_alpha_vantage_meta.py rename to tests/test_alpha_vantage_meta.py diff --git a/tests/test_google_adk.py b/tests/test_google_adk.py new file mode 100644 index 0000000..9cf926f --- /dev/null +++ b/tests/test_google_adk.py @@ -0,0 +1,44 @@ +#!/usr/bin/env python3 +# -*- coding: utf-8 -*- +""" +测试 Google ADK 安装和基本功能 +""" + +import os +from google.adk import Agent + +def test_adk_installation(): + """测试 ADK 安装是否成功""" + try: + # 创建一个简单的测试智能体 + test_agent = Agent( + name="测试智能体", + model="gemini-2.0-flash-exp" + ) + + print("✅ Google ADK 安装成功！") + print(f"智能体名称: {test_agent.name}") + print(f"使用模型: {test_agent.model}") + print(f"描述: {test_agent.description}") + + # 检查环境变量 + google_api_key = os.getenv('GOOGLE_API_KEY') + if google_api_key: + print(f"✅ GOOGLE_API_KEY 已配置 (长度: {len(google_api_key)} 字符)") + else: + print("⚠️ GOOGLE_API_KEY 未配置，需要设置 API 密钥") + print("请访问 https://aistudio.google.com/ 获取 API 密钥") + + return True + + except Exception as e: + print(f"❌ ADK 安装测试失败: {e}") + return False + +if __name__ == "__main__": + print("🚀 开始测试 Google ADK 安装...") + test_adk_installation() + print("\n📝 下一步: 配置 GOOGLE_API_KEY 环境变量") + print(" 1. 访问 https://aistudio.google.com/") + print(" 2. 获取 API 密钥") + print(" 3. 在 Doppler 中设置: doppler secrets set GOOGLE_API_KEY=your_key") \ No newline at end of file diff --git a/tests/test_memory_bank.py b/tests/test_memory_bank.py new file mode 100644 index 0000000..1f1c519 --- /dev/null +++ b/tests/test_memory_bank.py @@ -0,0 +1,147 @@ +#!/usr/bin/env python3 +# -*- coding: utf-8 -*- +""" +测试 Google ADK Memory Bank 功能 +""" + +import os +import asyncio +from google.adk import Agent +from google.adk.memory import MemoryBank, MemoryItem +from datetime import datetime + +async def test_memory_bank(): + """测试Memory Bank基本功能""" + print("🧠 测试 Google ADK Memory Bank...") + + try: + # 创建记忆银行 + memory_bank = MemoryBank( + name="test_memory_bank", + description="测试用的记忆银行" + ) + + print("✅ Memory Bank 创建成功") + + # 添加记忆项 + memory_item = MemoryItem( + content="这是一个测试记忆：比特币在2021年达到历史最高点69000美元", + metadata={ + "type": "market_data", + "asset": "bitcoin", + "timestamp": datetime.now().isoformat() + } + ) + + await memory_bank.add_memory(memory_item) + print("✅ 记忆添加成功") + + # 搜索记忆 + search_results = await memory_bank.search("比特币", limit=5) + print(f"✅ 记忆搜索成功，找到 {len(search_results)} 条相关记忆") + + for i, memory in enumerate(search_results): + print(f" {i+1}. {memory.content}") + + # 创建带记忆银行的智能体 + agent = Agent( + name="测试智能体", + model="gemini-2.0-flash-exp", + instruction="你是一个测试智能体，请使用你的记忆银行来回答问题。", + memory_bank=memory_bank + ) + + print("✅ 带记忆银行的智能体创建成功") + + return True + + except ImportError as e: + print(f"❌ Memory Bank 模块导入失败: {e}") + print("💡 可能需要更新 Google ADK 版本或启用 Memory Bank 功能") + return False + except Exception as e: + print(f"❌ Memory Bank 测试失败: {e}") + return False + +async def test_simple_memory_simulation(): + """模拟Memory Bank功能的简单实现""" + print("\n🔄 使用简单模拟实现...") + + class SimpleMemoryBank: + def __init__(self, name: str, description: str): + self.name = name + self.description = description + self.memories = [] + + async def add_memory(self, content: str, metadata: dict = None): + memory = { + "content": content, + "metadata": metadata or {}, + "timestamp": datetime.now().isoformat() + } + self.memories.append(memory) + + async def search(self, query: str, limit: int = 5): + # 简单的关键词匹配 + results = [] + query_lower = query.lower() + + for memory in self.memories: + if query_lower in memory["content"].lower(): + results.append(memory) + if len(results) >= limit: + break + + return results + + # 测试简单实现 + memory_bank = SimpleMemoryBank( + name="铁拐李记忆银行", + description="铁拐李的逆向投资记忆" + ) + + # 添加一些记忆 + memories = [ + "2000年互联网泡沫破裂，纳斯达克指数从5048点跌到1114点", + "2008年金融危机，雷曼兄弟破产引发全球恐慌", + "2020年3月疫情恐慌，美股熔断4次，但随后强劲反弹", + "比特币从2017年的2万美元跌到2018年的3200美元" + ] + + for memory in memories: + await memory_bank.add_memory(memory, {"type": "historical_event"}) + + print(f"✅ 已添加 {len(memories)} 条记忆") + + # 搜索测试 + search_queries = ["泡沫", "比特币", "金融危机"] + + for query in search_queries: + results = await memory_bank.search(query) + print(f"\n🔍 搜索 '{query}' 找到 {len(results)} 条记忆:") + for i, result in enumerate(results): + print(f" {i+1}. {result['content']}") + + return True + +async def main(): + """主测试函数""" + print("🚀 Google ADK Memory Bank 功能测试") + + # 检查API密钥 + api_key = os.getenv('GOOGLE_API_KEY') + if not api_key: + print("❌ 未找到 GOOGLE_API_KEY 环境变量") + return + + print(f"✅ API密钥已配置") + + # 尝试真实的Memory Bank + success = await test_memory_bank() + + if not success: + # 如果真实的Memory Bank不可用，使用模拟实现 + await test_simple_memory_simulation() + +if __name__ == "__main__": + asyncio.run(main()) \ No newline at end of file diff --git a/tests/test_vertex_memory_bank.py b/tests/test_vertex_memory_bank.py new file mode 100644 index 0000000..937fe8a --- /dev/null +++ b/tests/test_vertex_memory_bank.py @@ -0,0 +1,257 @@ +#!/usr/bin/env python3 +""" +Vertex AI Memory Bank 测试脚本 +验证稷下学宫记忆银行功能 +""" + +import asyncio +import sys +import os + +# 添加项目根目录到路径 +sys.path.append(os.path.dirname(os.path.dirname(os.path.abspath(__file__)))) + +from src.jixia.memory.vertex_memory_bank import VertexMemoryBank, initialize_baxian_memory_banks +from src.jixia.agents.memory_enhanced_agent import MemoryEnhancedAgent, create_memory_enhanced_council +from config.doppler_config import get_google_genai_config, validate_config + + +async def test_memory_bank_basic(): + """测试Memory Bank基础功能""" + print("🧪 测试 Memory Bank 基础功能...") + + try: + # 验证配置 + if not validate_config("google_adk"): + print("❌ Google ADK 配置验证失败") + return False + + config = get_google_genai_config() + if not config.get('project_id'): + print("❌ Google Cloud Project ID 未配置") + print("请设置环境变量: GOOGLE_CLOUD_PROJECT_ID") + return False + + # 创建Memory Bank实例 + memory_bank = VertexMemoryBank.from_config() + print(f"✅ Memory Bank 实例创建成功") + print(f" 项目ID: {config['project_id']}") + print(f" 区域: {config['location']}") + + # 测试创建记忆银行 + bank_id = await memory_bank.create_memory_bank( + agent_name="tieguaili", + display_name="铁拐李测试记忆银行" + ) + print(f"✅ 创建记忆银行成功: {bank_id}") + + # 测试添加记忆 + memory_id = await memory_bank.add_memory( + agent_name="tieguaili", + content="测试记忆：在分析NVIDIA时，我倾向于关注潜在的市场风险和估值泡沫。", + memory_type="preference", + debate_topic="NVIDIA投资分析", + metadata={"test": True, "priority": "high"} + ) + print(f"✅ 添加记忆成功: {memory_id}") + + # 测试搜索记忆 + results = await memory_bank.search_memories( + agent_name="tieguaili", + query="NVIDIA 风险", + limit=5 + ) + print(f"✅ 搜索记忆成功，找到 {len(results)} 条结果") + + for i, result in enumerate(results, 1): + print(f" {i}. {result['content'][:50]}... (相关度: {result.get('relevance_score', 'N/A')})") + + # 测试获取上下文 + context = await memory_bank.get_agent_context("tieguaili", "NVIDIA投资分析") + print(f"✅ 获取上下文成功，长度: {len(context)} 字符") + + return True + + except Exception as e: + print(f"❌ Memory Bank 基础测试失败: {e}") + return False + + +async def test_memory_enhanced_agent(): + """测试记忆增强智能体""" + print("\n🧪 测试记忆增强智能体...") + + try: + # 创建记忆银行 + memory_bank = VertexMemoryBank.from_config() + + # 创建记忆增强智能体 + agent = MemoryEnhancedAgent("tieguaili", memory_bank) + print(f"✅ 创建记忆增强智能体: {agent.personality.chinese_name}") + + # 测试基于记忆的响应 + response = await agent.respond_with_memory( + message="你对NVIDIA的最新财报有什么看法？", + topic="NVIDIA投资分析" + ) + print(f"✅ 智能体响应成功") + print(f" 响应长度: {len(response)} 字符") + print(f" 响应预览: {response[:100]}...") + + # 测试学习偏好 + await agent.learn_preference( + preference="用户偏好保守的投资策略，关注风险控制", + topic="投资偏好" + ) + print("✅ 学习用户偏好成功") + + # 测试保存策略洞察 + await agent.save_strategy_insight( + insight="在高估值环境下，应该更加关注基本面分析和风险管理", + topic="投资策略" + ) + print("✅ 保存策略洞察成功") + + return True + + except Exception as e: + print(f"❌ 记忆增强智能体测试失败: {e}") + return False + + +async def test_baxian_memory_council(): + """测试八仙记忆议会""" + print("\n🧪 测试八仙记忆议会...") + + try: + # 创建记忆增强议会 + council = await create_memory_enhanced_council() + print(f"✅ 创建八仙记忆议会成功，智能体数量: {len(council.agents)}") + + # 列出所有智能体 + for agent_name, agent in council.agents.items(): + print(f" - {agent.personality.chinese_name} ({agent_name})") + + # 进行简短的记忆辩论测试 + print("\n🏛️ 开始记忆增强辩论测试...") + result = await council.conduct_memory_debate( + topic="比特币投资价值分析", + participants=["tieguaili", "lvdongbin"], # 只选择两个智能体进行快速测试 + rounds=1 + ) + + print(f"✅ 辩论完成") + print(f" 主题: {result['topic']}") + print(f" 参与者: {len(result['participants'])} 位") + print(f" 发言次数: {result['total_exchanges']}") + + # 显示辩论内容 + for exchange in result['conversation_history']: + print(f" {exchange['chinese_name']}: {exchange['content'][:80]}...") + + # 获取集体记忆摘要 + summary = await council.get_collective_memory_summary("比特币投资价值分析") + print(f"\n📚 集体记忆摘要长度: {len(summary)} 字符") + + return True + + except Exception as e: + print(f"❌ 八仙记忆议会测试失败: {e}") + return False + + +async def test_memory_bank_initialization(): + """测试Memory Bank初始化""" + print("\n🧪 测试 Memory Bank 初始化...") + + try: + config = get_google_genai_config() + project_id = config.get('project_id') + location = config.get('location', 'us-central1') + + if not project_id: + print("❌ 项目ID未配置，跳过初始化测试") + return False + + # 初始化所有八仙记忆银行 + memory_bank = await initialize_baxian_memory_banks(project_id, location) + print(f"✅ 八仙记忆银行初始化成功") + print(f" 记忆银行数量: {len(memory_bank.memory_banks)}") + + for agent_name, bank_name in memory_bank.memory_banks.items(): + chinese_name = memory_bank.baxian_agents.get(agent_name, agent_name) + print(f" - {chinese_name}: {bank_name}") + + return True + + except Exception as e: + print(f"❌ Memory Bank 初始化测试失败: {e}") + return False + + +async def main(): + """主测试函数""" + print("🏛️ 稷下学宫 Vertex AI Memory Bank 测试") + print("=" * 50) + + # 检查配置 + print("🔧 检查配置...") + config = get_google_genai_config() + + print(f"Google API Key: {'已配置' if config.get('api_key') else '未配置'}") + print(f"Project ID: {config.get('project_id', '未配置')}") + print(f"Location: {config.get('location', 'us-central1')}") + print(f"Memory Bank: {'启用' if config.get('memory_bank_enabled', 'TRUE') == 'TRUE' else '禁用'}") + + if not config.get('project_id'): + print("\n❌ 测试需要 Google Cloud Project ID") + print("请设置环境变量: GOOGLE_CLOUD_PROJECT_ID=your-project-id") + return + + # 运行测试 + tests = [ + ("Memory Bank 基础功能", test_memory_bank_basic), + ("记忆增强智能体", test_memory_enhanced_agent), + ("八仙记忆议会", test_baxian_memory_council), + ("Memory Bank 初始化", test_memory_bank_initialization) + ] + + results = [] + + for test_name, test_func in tests: + print(f"\n{'='*20}") + print(f"测试: {test_name}") + print(f"{'='*20}") + + try: + result = await test_func() + results.append((test_name, result)) + except Exception as e: + print(f"❌ 测试 {test_name} 出现异常: {e}") + results.append((test_name, False)) + + # 显示测试结果摘要 + print(f"\n{'='*50}") + print("🏛️ 测试结果摘要") + print(f"{'='*50}") + + passed = 0 + total = len(results) + + for test_name, result in results: + status = "✅ 通过" if result else "❌ 失败" + print(f"{status} {test_name}") + if result: + passed += 1 + + print(f"\n📊 总体结果: {passed}/{total} 测试通过") + + if passed == total: + print("🎉 所有测试通过！Vertex AI Memory Bank 集成成功！") + else: + print("⚠️ 部分测试失败，请检查配置和网络连接") + + +if __name__ == "__main__": + # 运行测试 + asyncio.run(main()) \ No newline at end of file diff --git a/validate-config.js b/validate-config.js new file mode 100644 index 0000000..e1298cc --- /dev/null +++ b/validate-config.js @@ -0,0 +1,107 @@ +// Simple configuration validation script +// This validates the wrangler.toml and Worker code without requiring API access + +const fs = require('fs'); +const path = require('path'); + +console.log('🔍 Validating Hyperdrive Configuration Files'); +console.log('============================================'); + +// Check wrangler.toml +console.log('\n📋 Checking wrangler.toml...'); +try { + const wranglerContent = fs.readFileSync('wrangler.toml', 'utf8'); + console.log('✅ wrangler.toml exists'); + + // Check for required fields + const checks = [ + { field: 'name', regex: /name\s*=\s*["']([^"']+)["']/, required: true }, + { field: 'main', regex: /main\s*=\s*["']([^"']+)["']/, required: true }, + { field: 'compatibility_date', regex: /compatibility_date\s*=\s*["']([^"']+)["']/, required: true }, + { field: 'nodejs_compat', regex: /nodejs_compat/, required: true }, + { field: 'hyperdrive binding', regex: /binding\s*=\s*["']HYPERDRIVE["']/, required: true }, + { field: 'hyperdrive id', regex: /id\s*=\s*["']ef43924d89064cddabfaccf06aadfab6["']/, required: true } + ]; + + checks.forEach(check => { + if (check.regex.test(wranglerContent)) { + console.log(` ✅ ${check.field} configured`); + } else { + console.log(` ❌ ${check.field} missing or incorrect`); + } + }); + +} catch (error) { + console.log('❌ wrangler.toml not found or unreadable'); +} + +// Check Worker code +console.log('\n📝 Checking Worker code...'); +try { + const workerContent = fs.readFileSync('src/index.ts', 'utf8'); + console.log('✅ src/index.ts exists'); + + const codeChecks = [ + { name: 'Hyperdrive binding usage', regex: /env\.HYPERDRIVE/ }, + { name: 'Test connection endpoint', regex: /\/test-connection/ }, + { name: 'Test query endpoint', regex: /\/test-query/ }, + { name: 'PostgreSQL import', regex: /pg/ }, + { name: 'Error handling', regex: /try\s*{[\s\S]*catch/ } + ]; + + codeChecks.forEach(check => { + if (check.regex.test(workerContent)) { + console.log(` ✅ ${check.name} implemented`); + } else { + console.log(` ⚠️ ${check.name} not found`); + } + }); + +} catch (error) { + console.log('❌ src/index.ts not found or unreadable'); +} + +// Check package.json +console.log('\n📦 Checking package.json...'); +try { + const packageContent = fs.readFileSync('package.json', 'utf8'); + const packageJson = JSON.parse(packageContent); + console.log('✅ package.json exists and is valid JSON'); + + const deps = { + 'pg': packageJson.dependencies?.pg, + '@cloudflare/workers-types': packageJson.devDependencies?.['@cloudflare/workers-types'], + '@types/pg': packageJson.devDependencies?.['@types/pg'], + 'typescript': packageJson.devDependencies?.typescript, + 'wrangler': packageJson.devDependencies?.wrangler + }; + + Object.entries(deps).forEach(([dep, version]) => { + if (version) { + console.log(` ✅ ${dep}: ${version}`); + } else { + console.log(` ❌ ${dep}: not found`); + } + }); + +} catch (error) { + console.log('❌ package.json not found or invalid JSON'); +} + +console.log('\n📊 Configuration Summary:'); +console.log(' - Project: hyperdrive-neondb-test'); +console.log(' - Hyperdrive ID: ef43924d89064cddabfaccf06aadfab6'); +console.log(' - Database: NeonDB (PostgreSQL)'); +console.log(' - Binding: HYPERDRIVE'); +console.log(' - Compatibility: nodejs_compat enabled'); + +console.log('\n🚀 Next Steps:'); +console.log(' 1. Ensure you have proper Cloudflare API permissions'); +console.log(' 2. Verify the Hyperdrive configuration exists in your Cloudflare dashboard'); +console.log(' 3. Deploy with: wrangler deploy'); +console.log(' 4. Test endpoints after deployment'); + +console.log('\n💡 Troubleshooting:'); +console.log(' - If API token has insufficient permissions, use: wrangler login'); +console.log(' - Check Hyperdrive exists: https://dash.cloudflare.com/[account-id]/workers/hyperdrive'); +console.log(' - Verify NeonDB connection string is correct in Hyperdrive config'); \ No newline at end of file diff --git a/wrangler.toml b/wrangler.toml new file mode 100644 index 0000000..eccd252 --- /dev/null +++ b/wrangler.toml @@ -0,0 +1,16 @@ +name = "hyperdrive-neondb-test" +main = "src/index.ts" +compatibility_date = "2025-02-04" + +# Add nodejs_compat compatibility flag to support common database drivers +compatibility_flags = ["nodejs_compat"] + +[observability] +enabled = true + +# Hyperdrive configuration for NeonDB +[[hyperdrive]] +binding = "HYPERDRIVE" +id = "ef43924d89064cddabfaccf06aadfab6" +# For local development, use a local PostgreSQL connection +localConnectionString = "postgresql://postgres:password@localhost:5432/testdb"