asktable-advisor 1.0.1__py3-none-any.whl

asktable_advisor/asktable/client.py

@@ -0,0 +1,271 @@
+"""AskTable API client for Advisor Agent."""
+
+import logging
+from typing import Any, Dict, List, Optional
+
+from asktable import Asktable
+
+logger = logging.getLogger(__name__)
+
+
+class AskTableClient:
+    """
+    AskTable API client wrapper.
+
+    Provides a clean interface to interact with AskTable resources.
+    """
+
+    def __init__(self, api_key: str, base_url: str):
+        """
+        Initialize AskTable client.
+
+        Args:
+            api_key: AskTable API key
+            base_url: AskTable API base URL
+        """
+        self.api_key = api_key
+        self.base_url = base_url
+        self._client: Optional[Asktable] = None
+
+        logger.info(f"AskTable client initialized: {base_url}")
+
+    @property
+    def client(self) -> Asktable:
+        """Get or create AskTable SDK client."""
+        if self._client is None:
+            self._client = Asktable(
+                base_url=self.base_url,
+                api_key=self.api_key,
+            )
+        return self._client
+
+    def test_connection(self) -> bool:
+        """
+        Test AskTable API connection.
+
+        Returns:
+            True if connection successful, False otherwise
+        """
+        try:
+            self.client.datasources.list()
+            logger.info("AskTable API connection successful")
+            return True
+        except Exception as e:
+            logger.error(f"AskTable API connection failed: {e}")
+            return False
+
+    # Datasource operations
+    def list_datasources(self) -> List[Dict[str, Any]]:
+        """List all datasources in the project."""
+        try:
+            result = self.client.datasources.list()
+            datasources = result.items if hasattr(result, 'items') else result
+
+            ds_list = []
+            for ds in datasources:
+                if hasattr(ds, 'model_dump'):
+                    ds_list.append(ds.model_dump())
+                elif hasattr(ds, 'dict'):
+                    ds_list.append(ds.dict())
+                else:
+                    ds_list.append(ds)
+            return ds_list
+        except Exception as e:
+            logger.error(f"Failed to list datasources: {e}")
+            return []
+
+    def get_datasource(self, datasource_id: str) -> Optional[Dict[str, Any]]:
+        """Get datasource by ID."""
+        try:
+            datasource = self.client.datasources.retrieve(datasource_id)
+            if hasattr(datasource, 'model_dump'):
+                return datasource.model_dump()
+            elif hasattr(datasource, 'dict'):
+                return datasource.dict()
+            return datasource
+        except Exception as e:
+            logger.warning(f"Datasource not found: {e}")
+            return None
+
+    def create_datasource(
+        self,
+        name: str,
+        database_name: str,
+        description: Optional[str] = None,
+        host: Optional[str] = None,
+        port: Optional[int] = None,
+        username: Optional[str] = None,
+        password: Optional[str] = None,
+    ) -> Dict[str, Any]:
+        """Create a new datasource."""
+        try:
+            # Use provided connection info or fall back to env defaults
+            from ..config import get_settings
+            settings = get_settings()
+
+            datasource = self.client.datasources.create(
+                name=name,
+                engine="mysql",
+                access_config={
+                    "host": host or settings.mysql_host,
+                    "port": port or settings.mysql_port,
+                    "db": database_name,
+                    "user": username or settings.mysql_user,
+                    "password": password or settings.mysql_password,
+                },
+            )
+
+            logger.info(f"Created datasource: {name}")
+
+            if hasattr(datasource, 'model_dump'):
+                return datasource.model_dump()
+            elif hasattr(datasource, 'dict'):
+                return datasource.dict()
+            return datasource
+        except Exception as e:
+            logger.error(f"Failed to create datasource: {e}")
+            raise
+
+    def delete_datasource(self, datasource_id: str) -> bool:
+        """Delete a datasource."""
+        try:
+            self.client.datasources.delete(datasource_id)
+            logger.info(f"Deleted datasource: {datasource_id}")
+            return True
+        except Exception as e:
+            logger.error(f"Failed to delete datasource: {e}")
+            return False
+
+    # Bot operations
+    def list_bots(self) -> List[Dict[str, Any]]:
+        """List all bots in the project."""
+        try:
+            result = self.client.bots.list()
+            bots = result.items if hasattr(result, 'items') else result
+
+            bot_list = []
+            for bot in bots:
+                if hasattr(bot, 'model_dump'):
+                    bot_list.append(bot.model_dump())
+                elif hasattr(bot, 'dict'):
+                    bot_list.append(bot.dict())
+                else:
+                    bot_list.append(bot)
+            return bot_list
+        except Exception as e:
+            logger.error(f"Failed to list bots: {e}")
+            return []
+
+    def get_bot(self, bot_id: str) -> Optional[Dict[str, Any]]:
+        """Get bot by ID."""
+        try:
+            bot = self.client.bots.retrieve(bot_id)
+            if hasattr(bot, 'model_dump'):
+                return bot.model_dump()
+            elif hasattr(bot, 'dict'):
+                return bot.dict()
+            return bot
+        except Exception as e:
+            logger.warning(f"Bot not found: {e}")
+            return None
+
+    def create_bot(
+        self,
+        name: str,
+        datasource_id: str,
+        description: Optional[str] = None,
+        instructions: Optional[str] = None,
+        sample_questions: Optional[List[str]] = None,
+    ) -> Dict[str, Any]:
+        """Create a new bot."""
+        try:
+            bot = self.client.bots.create(
+                name=name,
+                datasource_ids=[datasource_id],
+                welcome_message=description,
+                magic_input=instructions,
+                sample_questions=sample_questions or [],
+            )
+
+            logger.info(f"Created bot: {name}")
+
+            if hasattr(bot, 'model_dump'):
+                return bot.model_dump()
+            elif hasattr(bot, 'dict'):
+                return bot.dict()
+            return bot
+        except Exception as e:
+            logger.error(f"Failed to create bot: {e}")
+            raise
+
+    def update_bot(
+        self,
+        bot_id: str,
+        name: Optional[str] = None,
+        instructions: Optional[str] = None,
+        sample_questions: Optional[List[str]] = None,
+    ) -> Dict[str, Any]:
+        """Update an existing bot."""
+        try:
+            update_data = {}
+            if name:
+                update_data["name"] = name
+            if instructions:
+                update_data["magic_input"] = instructions
+            if sample_questions:
+                update_data["sample_questions"] = sample_questions
+
+            bot = self.client.bots.update(bot_id, **update_data)
+            logger.info(f"Updated bot: {bot_id}")
+
+            if hasattr(bot, 'model_dump'):
+                return bot.model_dump()
+            elif hasattr(bot, 'dict'):
+                return bot.dict()
+            return bot
+        except Exception as e:
+            logger.error(f"Failed to update bot: {e}")
+            raise
+
+    # Chat operations
+    def list_chats(self) -> List[Dict[str, Any]]:
+        """List all chats in the project."""
+        try:
+            result = self.client.chats.list()
+            chats = result.items if hasattr(result, 'items') else result
+
+            chat_list = []
+            for chat in chats:
+                if hasattr(chat, 'model_dump'):
+                    chat_list.append(chat.model_dump())
+                elif hasattr(chat, 'dict'):
+                    chat_list.append(chat.dict())
+                else:
+                    chat_list.append(chat)
+            return chat_list
+        except Exception as e:
+            logger.error(f"Failed to list chats: {e}")
+            return []
+
+    def create_chat(
+        self,
+        bot_id: str,
+        name: str,
+    ) -> Dict[str, Any]:
+        """Create a new chat session."""
+        try:
+            chat = self.client.chats.create(
+                bot_id=bot_id,
+                name=name,
+            )
+
+            logger.info(f"Created chat: {name}")
+
+            if hasattr(chat, 'model_dump'):
+                return chat.model_dump()
+            elif hasattr(chat, 'dict'):
+                return chat.dict()
+            return chat
+        except Exception as e:
+            logger.error(f"Failed to create chat: {e}")
+            raise

asktable_advisor/asktable/inspector.py

@@ -0,0 +1,210 @@
+"""AskTable project inspector for analyzing existing resources."""
+
+import logging
+from typing import Any, Dict, List
+
+from .client import AskTableClient
+
+logger = logging.getLogger(__name__)
+
+
+class AskTableInspector:
+    """
+    Inspector for analyzing AskTable projects.
+
+    Reads and organizes information about existing datasources, bots, chats, etc.
+    """
+
+    def __init__(self, client: AskTableClient):
+        """
+        Initialize inspector.
+
+        Args:
+            client: AskTable client instance
+        """
+        self.client = client
+
+    def inspect_project(self, detailed: bool = False) -> Dict[str, Any]:
+        """
+        Inspect the entire AskTable project.
+
+        Args:
+            detailed: If True, include full configuration for each resource
+
+        Returns:
+            Dict containing organized project information
+        """
+        logger.info("Inspecting AskTable project...")
+
+        project_info = {
+            "datasources": self._inspect_datasources(detailed),
+            "bots": self._inspect_bots(detailed),
+            "chats": self._inspect_chats(detailed),
+            "summary": {},
+        }
+
+        # Add summary statistics
+        project_info["summary"] = {
+            "total_datasources": len(project_info["datasources"]),
+            "total_bots": len(project_info["bots"]),
+            "total_chats": len(project_info["chats"]),
+        }
+
+        logger.info(
+            f"Project inspection complete: "
+            f"{project_info['summary']['total_datasources']} datasources, "
+            f"{project_info['summary']['total_bots']} bots, "
+            f"{project_info['summary']['total_chats']} chats"
+        )
+
+        return project_info
+
+    def _inspect_datasources(self, detailed: bool) -> List[Dict[str, Any]]:
+        """Inspect all datasources."""
+        datasources = self.client.list_datasources()
+
+        if not detailed:
+            # Return simplified view
+            return [
+                {
+                    "id": ds.get("id"),
+                    "name": ds.get("name"),
+                    "engine": ds.get("engine"),
+                    "database": ds.get("access_config", {}).get("db"),
+                }
+                for ds in datasources
+            ]
+
+        return datasources
+
+    def _inspect_bots(self, detailed: bool) -> List[Dict[str, Any]]:
+        """Inspect all bots."""
+        bots = self.client.list_bots()
+
+        if not detailed:
+            # Return simplified view
+            return [
+                {
+                    "id": bot.get("id"),
+                    "name": bot.get("name"),
+                    "datasource_ids": bot.get("datasource_ids", []),
+                    "sample_question_count": len(bot.get("sample_questions", [])),
+                }
+                for bot in bots
+            ]
+
+        return bots
+
+    def _inspect_chats(self, detailed: bool) -> List[Dict[str, Any]]:
+        """Inspect all chats."""
+        chats = self.client.list_chats()
+
+        if not detailed:
+            # Return simplified view
+            return [
+                {
+                    "id": chat.get("id"),
+                    "name": chat.get("name"),
+                    "bot_id": chat.get("bot_id"),
+                }
+                for chat in chats
+            ]
+
+        return chats
+
+    def identify_scenarios(self) -> List[Dict[str, Any]]:
+        """
+        Identify distinct scenarios in the project.
+
+        A scenario is typically a datasource + associated bots + chats.
+
+        Returns:
+            List of identified scenarios
+        """
+        datasources = self.client.list_datasources()
+        bots = self.client.list_bots()
+        chats = self.client.list_chats()
+
+        scenarios = []
+
+        for ds in datasources:
+            ds_id = ds.get("id")
+
+            # Find bots using this datasource
+            related_bots = [
+                bot for bot in bots
+                if ds_id in bot.get("datasource_ids", [])
+            ]
+
+            # Find chats for these bots
+            related_chats = []
+            for bot in related_bots:
+                bot_id = bot.get("id")
+                bot_chats = [
+                    chat for chat in chats
+                    if chat.get("bot_id") == bot_id
+                ]
+                related_chats.extend(bot_chats)
+
+            scenario = {
+                "datasource": {
+                    "id": ds.get("id"),
+                    "name": ds.get("name"),
+                    "engine": ds.get("engine"),
+                },
+                "bots": [
+                    {
+                        "id": bot.get("id"),
+                        "name": bot.get("name"),
+                        "sample_question_count": len(bot.get("sample_questions", [])),
+                    }
+                    for bot in related_bots
+                ],
+                "chats": [
+                    {
+                        "id": chat.get("id"),
+                        "name": chat.get("name"),
+                    }
+                    for chat in related_chats
+                ],
+            }
+
+            scenarios.append(scenario)
+
+        logger.info(f"Identified {len(scenarios)} scenarios")
+        return scenarios
+
+    def get_optimization_suggestions(self) -> List[str]:
+        """
+        Analyze project and provide optimization suggestions.
+
+        Returns:
+            List of suggestion strings
+        """
+        suggestions = []
+
+        datasources = self.client.list_datasources()
+        bots = self.client.list_bots()
+
+        # Check for datasources without bots
+        for ds in datasources:
+            ds_id = ds.get("id")
+            has_bots = any(
+                ds_id in bot.get("datasource_ids", [])
+                for bot in bots
+            )
+            if not has_bots:
+                suggestions.append(
+                    f"数据源 '{ds.get('name')}' 没有关联的 Bot，建议创建一个 Bot 来使用这个数据源"
+                )
+
+        # Check for bots with few sample questions
+        for bot in bots:
+            question_count = len(bot.get("sample_questions", []))
+            if question_count < 10:
+                suggestions.append(
+                    f"Bot '{bot.get('name')}' 只有 {question_count} 个示例问题，"
+                    f"建议添加更多（推荐 15-25 个）"
+                )
+
+        return suggestions

asktable_advisor/config.py

@@ -0,0 +1,79 @@
+"""Configuration management for AskTable Advisor AI Agent."""
+
+from pydantic import Field
+from pydantic_settings import BaseSettings, SettingsConfigDict
+
+
+class AdvisorSettings(BaseSettings):
+    """Application settings loaded from environment variables."""
+
+    model_config = SettingsConfigDict(
+        env_file=".env",
+        env_file_encoding="utf-8",
+        case_sensitive=False,
+        extra="ignore",
+    )
+
+    # AskTable API Configuration
+    asktable_api_key: str = Field(..., description="AskTable API key")
+    asktable_api_base: str = Field(
+        default="https://api.asktable.com",
+        description="AskTable API base URL",
+    )
+
+    # LLM API Configuration (Aliyun Bailian - qwen3-max)
+    anthropic_base_url: str = Field(
+        default="https://dashscope.aliyuncs.com/apps/anthropic",
+        description="Anthropic-compatible API base URL (Aliyun Bailian)",
+    )
+    anthropic_api_key: str = Field(
+        ...,
+        description="DashScope API key for Aliyun Bailian",
+    )
+
+    # Agent Configuration
+    agent_model: str = Field(
+        default="qwen3-max",
+        description="LLM model to use for the advisor agent",
+    )
+    agent_temperature: float = Field(
+        default=0.7,
+        description="Temperature for LLM responses (0.0-1.0)",
+    )
+    agent_max_tokens: int = Field(
+        default=4096,
+        description="Maximum tokens for LLM responses",
+    )
+
+    # MySQL Database Configuration
+    mysql_host: str = Field(..., description="MySQL host")
+    mysql_port: int = Field(default=3306, description="MySQL port")
+    mysql_user: str = Field(..., description="MySQL username")
+    mysql_password: str = Field(..., description="MySQL password")
+    mysql_database: str = Field(
+        default="asktable_advisor",
+        description="MySQL database name",
+    )
+
+    # Optional: Database connection pool settings
+    mysql_pool_size: int = Field(
+        default=5,
+        description="Database connection pool size",
+    )
+    mysql_max_overflow: int = Field(
+        default=10,
+        description="Maximum overflow connections",
+    )
+
+    @property
+    def mysql_url(self) -> str:
+        """Generate SQLAlchemy database URL."""
+        return (
+            f"mysql+pymysql://{self.mysql_user}:{self.mysql_password}"
+            f"@{self.mysql_host}:{self.mysql_port}/{self.mysql_database}"
+        )
+
+
+def get_settings() -> AdvisorSettings:
+    """Load and return application settings."""
+    return AdvisorSettings()