asktable-advisor 1.0.1__py3-none-any.whl

asktable_advisor/__init__.py

@@ -0,0 +1,18 @@
+"""
+AskTable Advisor - AI Agent for AskTable scenario building.
+
+A conversational AI agent that helps users quickly create and manage
+high-quality AskTable demo projects.
+"""
+
+from .__version__ import __version__, __version_info__
+from .config import AdvisorSettings, get_settings
+from .agent.advisor import AdvisorAgent
+
+__all__ = [
+    "__version__",
+    "__version_info__",
+    "AdvisorSettings",
+    "get_settings",
+    "AdvisorAgent",
+]

asktable_advisor/__main__.py

@@ -0,0 +1,156 @@
+"""Command-line interface for AskTable Advisor."""
+
+import sys
+import logging
+from pathlib import Path
+
+from rich.console import Console
+from rich.panel import Panel
+from rich.markdown import Markdown
+from rich.prompt import Prompt
+
+from .config import AdvisorSettings, get_settings
+from .agent.advisor import AdvisorAgent
+
+# Setup console
+console = Console()
+
+# Setup logging
+logging.basicConfig(
+    level=logging.INFO,
+    format="%(asctime)s - %(name)s - %(levelname)s - %(message)s",
+    handlers=[
+        logging.FileHandler("asktable_advisor.log"),
+        logging.StreamHandler(sys.stderr),
+    ],
+)
+
+
+def print_welcome() -> None:
+    """Print welcome message."""
+    welcome_text = """
+# 🤖 AskTable Advisor v1.0
+
+你好！我是 AskTable Advisor，你的 AskTable 场景构建助手。
+
+## 我能帮你：
+- 🎨 **创建新场景**：告诉我场景名称（如"电商平台"、"在线教育"），我会自动设计并构建完整的演示项目
+- 📊 **查看现有场景**：检查你的 AskTable 项目中已有的资源
+- ✨ **完善场景**：优化现有场景，添加更多功能
+
+## 使用方式：
+直接用自然语言告诉我你想做什么！例如：
+- "创建一个在线教育平台的演示场景"
+- "看看我现在有哪些场景"
+- "给电商 Bot 添加更多示例问题"
+
+输入 **exit** 或 **quit** 退出。
+
+开始对话吧！
+"""
+    console.print(Panel(Markdown(welcome_text), border_style="cyan"))
+
+
+def run_chat_loop(agent: AdvisorAgent) -> None:
+    """
+    Run the main chat loop.
+
+    Args:
+        agent: Advisor agent instance
+    """
+    while True:
+        try:
+            # Get user input
+            user_input = Prompt.ask("\n[bold cyan]你[/bold cyan]").strip()
+
+            # Check for exit commands
+            if user_input.lower() in ["exit", "quit", "退出", "再见"]:
+                console.print("\n[dim]再见！如有需要随时回来 👋[/dim]\n")
+                break
+
+            # Skip empty input
+            if not user_input:
+                continue
+
+            # Process with agent
+            console.print("\n[bold green]Advisor[/bold green]: ", end="")
+
+            try:
+                response = agent.chat(user_input)
+                console.print(response)
+
+            except Exception as e:
+                console.print(f"\n[red]错误：{str(e)}[/red]")
+                logging.error(f"Error processing message: {e}", exc_info=True)
+
+        except KeyboardInterrupt:
+            console.print("\n\n[dim]检测到 Ctrl+C，退出程序...[/dim]\n")
+            break
+
+        except EOFError:
+            console.print("\n\n[dim]输入结束，退出程序...[/dim]\n")
+            break
+
+
+def test_connections(agent: AdvisorAgent) -> bool:
+    """
+    Test all connections.
+
+    Args:
+        agent: Advisor agent instance
+
+    Returns:
+        True if all connections successful
+    """
+    console.print("\n[cyan]正在测试连接...[/cyan]\n")
+
+    results = agent.test_connections()
+
+    all_ok = True
+    for service, ok in results.items():
+        status = "[green]✓[/green]" if ok else "[red]✗[/red]"
+        console.print(f"{status} {service.upper()} 连接")
+        all_ok = all_ok and ok
+
+    console.print()
+
+    if not all_ok:
+        console.print(
+            "[yellow]警告：部分服务连接失败，某些功能可能无法使用[/yellow]\n"
+        )
+
+    return all_ok
+
+
+def main() -> None:
+    """Main entry point for CLI."""
+    try:
+        # Load settings
+        settings = get_settings()
+
+        # Print welcome
+        print_welcome()
+
+        # Initialize agent
+        console.print("[dim]正在初始化 Advisor Agent...[/dim]")
+        agent = AdvisorAgent(settings)
+
+        # Test connections
+        test_connections(agent)
+
+        # Start chat loop
+        console.print("[dim]准备就绪！开始对话：[/dim]\n")
+        run_chat_loop(agent)
+
+    except KeyboardInterrupt:
+        console.print("\n\n[dim]程序被中断[/dim]\n")
+        sys.exit(0)
+
+    except Exception as e:
+        console.print(f"\n[red bold]错误：{str(e)}[/red bold]\n")
+        logging.error(f"Fatal error: {e}", exc_info=True)
+        sys.exit(1)
+
+
+if __name__ == "__main__":
+    main()

asktable_advisor/__version__.py

@@ -0,0 +1,4 @@
+"""Version information for asktable-advisor."""
+
+__version__ = "1.0.0"
+__version_info__ = tuple(int(x) for x in __version__.split("."))

asktable_advisor/agent/__init__.py

@@ -0,0 +1,6 @@
+"""AskTable Advisor Agent module."""
+
+from .advisor import AdvisorAgent
+from .llm_client import LLMClient
+
+__all__ = ["AdvisorAgent", "LLMClient"]

asktable_advisor/agent/advisor.py

@@ -0,0 +1,337 @@
+"""Main Advisor Agent with conversational AI and tool execution."""
+
+import json
+import logging
+from typing import Any, Dict, List, Optional
+
+from anthropic.types import Message, MessageParam
+
+from ..config import AdvisorSettings
+from ..asktable.client import AskTableClient
+from ..asktable.inspector import AskTableInspector
+from ..database.manager import DatabaseManager
+from ..database.schema_generator import SchemaGenerator
+from ..database.data_generator import DataGenerator
+from .llm_client import LLMClient
+from .tools import get_tools
+from .prompts import get_system_prompt
+
+logger = logging.getLogger(__name__)
+
+
+class AdvisorAgent:
+    """
+    AskTable Advisor AI Agent.
+
+    Conversational agent that helps users create and manage AskTable scenarios.
+    """
+
+    def __init__(self, settings: AdvisorSettings):
+        """
+        Initialize Advisor Agent.
+
+        Args:
+            settings: Application settings
+        """
+        self.settings = settings
+
+        # Initialize components
+        self.llm_client = LLMClient(settings)
+        self.db_manager = DatabaseManager(settings)
+        self.asktable_client = AskTableClient(
+            api_key=settings.asktable_api_key,
+            base_url=settings.asktable_api_base,
+        )
+        self.asktable_inspector = AskTableInspector(self.asktable_client)
+
+        # Generators
+        self.schema_generator = SchemaGenerator(self.llm_client)
+        self.data_generator = DataGenerator(self.llm_client)
+
+        # Conversation state
+        self.conversation_history: List[MessageParam] = []
+        self.system_prompt = get_system_prompt()
+        self.tools = get_tools()
+
+        logger.info("Advisor Agent initialized")
+
+    def chat(self, user_message: str) -> str:
+        """
+        Process user message and return response.
+
+        Args:
+            user_message: User's input message
+
+        Returns:
+            Agent's response text
+        """
+        # Add user message to history
+        self.conversation_history.append({
+            "role": "user",
+            "content": user_message,
+        })
+
+        # Process with LLM and tools
+        response_text = self._process_turn()
+
+        return response_text
+
+    def _process_turn(self) -> str:
+        """Process one conversation turn with potential tool use."""
+        max_iterations = 10  # Prevent infinite loops
+        iteration = 0
+
+        while iteration < max_iterations:
+            iteration += 1
+
+            # Call LLM
+            response = self.llm_client.create_message(
+                messages=self.conversation_history,
+                system=self.system_prompt,
+                tools=self.tools,
+            )
+
+            # Check if LLM wants to use tools
+            if self.llm_client.has_tool_use(response):
+                # Execute tools and continue
+                self._execute_tools(response)
+            else:
+                # LLM has final response
+                response_text = self.llm_client.extract_text(response)
+
+                # Add assistant response to history
+                self.conversation_history.append({
+                    "role": "assistant",
+                    "content": response_text,
+                })
+
+                return response_text
+
+        # Max iterations reached
+        error_msg = "对话迭代次数过多，请重新开始"
+        logger.warning(f"Max iterations reached in conversation")
+        return error_msg
+
+    def _execute_tools(self, message: Message) -> None:
+        """
+        Execute tools requested by LLM.
+
+        Args:
+            message: LLM message containing tool use blocks
+        """
+        # Add assistant message with tool use to history
+        self.conversation_history.append({
+            "role": "assistant",
+            "content": message.content,
+        })
+
+        # Extract and execute each tool
+        tool_uses = self.llm_client.extract_tool_uses(message)
+
+        for tool_use in tool_uses:
+            tool_name = tool_use.name
+            tool_input = tool_use.input
+            tool_use_id = tool_use.id
+
+            logger.info(f"Executing tool: {tool_name}")
+
+            try:
+                # Execute tool
+                result = self._execute_tool(tool_name, tool_input)
+
+                # Format result
+                tool_result = self.llm_client.format_tool_result(
+                    tool_use_id=tool_use_id,
+                    content=result,
+                    is_error=False,
+                )
+
+            except Exception as e:
+                logger.error(f"Tool execution failed: {e}")
+                tool_result = self.llm_client.format_tool_result(
+                    tool_use_id=tool_use_id,
+                    content=f"工具执行失败：{str(e)}",
+                    is_error=True,
+                )
+
+            # Add tool result to history
+            self.conversation_history.append({
+                "role": "user",
+                "content": [tool_result],
+            })
+
+    def _execute_tool(self, tool_name: str, tool_input: Dict[str, Any]) -> Any:
+        """
+        Execute a specific tool.
+
+        Args:
+            tool_name: Name of the tool to execute
+            tool_input: Tool input parameters
+
+        Returns:
+            Tool execution result
+        """
+        # Dispatch to appropriate handler
+        if tool_name == "inspect_asktable_project":
+            return self._tool_inspect_project(tool_input)
+
+        elif tool_name == "design_database_schema":
+            return self._tool_design_schema(tool_input)
+
+        elif tool_name == "generate_sample_data":
+            return self._tool_generate_data(tool_input)
+
+        elif tool_name == "execute_sql":
+            return self._tool_execute_sql(tool_input)
+
+        elif tool_name == "create_asktable_datasource":
+            return self._tool_create_datasource(tool_input)
+
+        elif tool_name == "create_asktable_bot":
+            return self._tool_create_bot(tool_input)
+
+        elif tool_name == "create_asktable_chat":
+            return self._tool_create_chat(tool_input)
+
+        elif tool_name == "enhance_bot":
+            return self._tool_enhance_bot(tool_input)
+
+        elif tool_name == "create_permissions":
+            return self._tool_create_permissions(tool_input)
+
+        elif tool_name == "ask_user":
+            return self._tool_ask_user(tool_input)
+
+        else:
+            raise ValueError(f"Unknown tool: {tool_name}")
+
+    # Tool implementations
+    def _tool_inspect_project(self, params: Dict[str, Any]) -> Dict[str, Any]:
+        """Inspect AskTable project."""
+        detailed = params.get("detailed", False)
+        return self.asktable_inspector.inspect_project(detailed=detailed)
+
+    def _tool_design_schema(self, params: Dict[str, Any]) -> str:
+        """Design database schema."""
+        return self.schema_generator.generate_schema(
+            scenario_name=params["scenario_name"],
+            scenario_description=params["scenario_description"],
+            requirements=params.get("requirements"),
+            scale_info=params.get("scale_info"),
+        )
+
+    def _tool_generate_data(self, params: Dict[str, Any]) -> str:
+        """Generate sample data."""
+        return self.data_generator.generate_data(
+            schema_sql=params["schema_sql"],
+            scenario_context=params.get("scenario_context", ""),
+            data_volume=params["data_volume"],
+        )
+
+    def _tool_execute_sql(self, params: Dict[str, Any]) -> Dict[str, Any]:
+        """Execute SQL statements."""
+        sql = params["sql"]
+        description = params.get("description", "执行 SQL")
+
+        count = self.db_manager.execute_sql(sql, description)
+
+        return {
+            "success": True,
+            "statements_executed": count,
+            "message": f"成功执行 {count} 条 SQL 语句",
+        }
+
+    def _tool_create_datasource(self, params: Dict[str, Any]) -> Dict[str, Any]:
+        """Create AskTable datasource."""
+        datasource = self.asktable_client.create_datasource(
+            name=params["name"],
+            database_name=params["database_name"],
+            description=params.get("description"),
+        )
+        return datasource
+
+    def _tool_create_bot(self, params: Dict[str, Any]) -> Dict[str, Any]:
+        """Create AskTable bot."""
+        bot = self.asktable_client.create_bot(
+            name=params["name"],
+            datasource_id=params["datasource_id"],
+            description=params.get("description"),
+            instructions=params.get("instructions"),
+            sample_questions=params.get("sample_questions"),
+        )
+        return bot
+
+    def _tool_create_chat(self, params: Dict[str, Any]) -> Dict[str, Any]:
+        """Create AskTable chat."""
+        chat = self.asktable_client.create_chat(
+            bot_id=params["bot_id"],
+            name=params["name"],
+        )
+        return chat
+
+    def _tool_enhance_bot(self, params: Dict[str, Any]) -> Dict[str, Any]:
+        """Enhance existing bot."""
+        bot_id = params["bot_id"]
+        action = params["action"]
+        content = params.get("content", {})
+
+        if action == "add_questions":
+            # Get current bot
+            bot = self.asktable_client.get_bot(bot_id)
+            if not bot:
+                raise ValueError(f"Bot not found: {bot_id}")
+
+            # Add new questions
+            current_questions = bot.get("sample_questions", [])
+            new_questions = content.get("questions", [])
+            all_questions = current_questions + new_questions
+
+            # Update bot
+            updated_bot = self.asktable_client.update_bot(
+                bot_id=bot_id,
+                sample_questions=all_questions,
+            )
+            return updated_bot
+
+        elif action == "update_instructions":
+            updated_bot = self.asktable_client.update_bot(
+                bot_id=bot_id,
+                instructions=content.get("instructions"),
+            )
+            return updated_bot
+
+        else:
+            raise ValueError(f"Unknown action: {action}")
+
+    def _tool_create_permissions(self, params: Dict[str, Any]) -> Dict[str, Any]:
+        """Create permissions (placeholder)."""
+        # This is a placeholder for future implementation
+        return {
+            "message": "权限配置功能尚未实现，这是占位符",
+            "datasource_id": params.get("datasource_id"),
+            "roles": params.get("roles", []),
+        }
+
+    def _tool_ask_user(self, params: Dict[str, Any]) -> str:
+        """Ask user a question (returns question to be displayed)."""
+        # In CLI mode, this will be handled by the CLI layer
+        # For now, just return the question
+        question = params["question"]
+        options = params.get("options")
+
+        if options:
+            return f"{question}\n选项：{', '.join(options)}"
+        return question
+
+    def reset_conversation(self) -> None:
+        """Reset conversation history."""
+        self.conversation_history = []
+        logger.info("Conversation reset")
+
+    def test_connections(self) -> Dict[str, bool]:
+        """Test all connections."""
+        return {
+            "llm": self.llm_client.test_connection(),
+            "database": self.db_manager.test_connection(),
+            "asktable": self.asktable_client.test_connection(),
+        }