aigility 0.0.1__py3-none-any.whl

adk/__init__.py

@@ -0,0 +1,45 @@
+"""
+AIGility ADK - Agent Development Kit
+
+基于 LangGraph/LangChain 的智能体开发框架，提供：
+- chat: 基础对话能力
+- chatflow: 对话流管理
+- workflow: 工作流引擎
+- knowledge: 知识库管理
+- memory: 记忆管理
+"""
+
+__version__ = "0.0.1"
+__author__ = "AIGility Cloud Innovation"
+__email__ = "contact@aigility.com"
+__description__ = "Agent Development Kit - 智能体开发框架"
+
+# 导入主客户端
+from .client import ADKClient, create_client
+
+# 导入各模块
+from . import memory
+from . import chat
+from . import chatflow
+from . import workflow
+from . import knowledge
+
+__all__ = [
+    # 主客户端
+    "ADKClient",
+    "create_client",
+    
+    # 模块
+    "memory",
+    "chat",
+    "chatflow",
+    "workflow",
+    "knowledge",
+    
+    # 元信息
+    "__version__",
+    "__author__",
+    "__email__",
+    "__description__",
+]
+

adk/chat/__init__.py

@@ -0,0 +1,13 @@
+"""
+ADK Chat - 基础对话模块
+
+基于 LangChain 提供基础对话能力。
+"""
+
+from .agent import ChatAgent, create_chat_agent
+
+__all__ = [
+    "ChatAgent",
+    "create_chat_agent",
+]
+

adk/chat/agent.py

@@ -0,0 +1,60 @@
+"""
+Chat Agent
+
+基于 LangChain 的对话智能体。
+"""
+
+from typing import Optional, List, Dict, Any
+from ..core.base import BaseAgent
+from ..core.types import State, Message, AgentResponse
+from ..core.config import AgentConfig
+
+
+class ChatAgent(BaseAgent):
+    """对话智能体"""
+    
+    def __init__(
+        self,
+        name: str,
+        config: Optional[AgentConfig] = None,
+        llm: Optional[Any] = None,  # LangChain LLM
+        tools: Optional[List[Any]] = None,  # LangChain Tools
+        memory: Optional[Any] = None,  # LangChain Memory
+    ):
+        super().__init__(name, config)
+        self.config = config or AgentConfig(name=name, description="")
+        self.llm = llm
+        self.tools = tools or []
+        self.memory = memory
+        
+        # TODO: 初始化 LangChain Agent
+        # 这里需要使用 LangChain 的 Agent 类
+        self._agent = None
+    
+    async def invoke(self, state: State) -> AgentResponse:
+        """
+        执行对话
+        
+        Args:
+            state: 当前状态
+            
+        Returns:
+            智能体响应
+        """
+        # TODO: 实现 LangChain Agent 调用
+        # 这里需要调用 LangChain 的 Agent
+        raise NotImplementedError("ChatAgent.invoke not yet implemented")
+    
+    def get_prompt(self) -> str:
+        """获取提示词"""
+        return self.config.prompt_template or ""
+
+
+def create_chat_agent(
+    name: str,
+    config: Optional[AgentConfig] = None,
+    **kwargs
+) -> ChatAgent:
+    """创建对话智能体"""
+    return ChatAgent(name=name, config=config, **kwargs)
+

adk/chatflow/__init__.py

@@ -0,0 +1,13 @@
+"""
+ADK ChatFlow - 对话流管理模块
+
+基于 LangGraph 提供对话流管理能力。
+"""
+
+from .flow import ChatFlow, create_chatflow
+
+__all__ = [
+    "ChatFlow",
+    "create_chatflow",
+]
+

adk/chatflow/flow.py

@@ -0,0 +1,63 @@
+"""
+ChatFlow
+
+基于 LangGraph 的对话流管理。
+"""
+
+from typing import Optional, Dict, Any, List
+from ..core.types import State, Message
+from ..core.config import AgentConfig
+
+
+class ChatFlow:
+    """对话流"""
+    
+    def __init__(
+        self,
+        name: str,
+        agents: Optional[Dict[str, Any]] = None,  # LangGraph Agents
+        graph: Optional[Any] = None,  # LangGraph StateGraph
+    ):
+        self.name = name
+        self.agents = agents or {}
+        self.graph = graph
+        
+        # TODO: 初始化 LangGraph StateGraph
+        # 这里需要使用 LangGraph 的 StateGraph 类
+    
+    async def invoke(self, state: State) -> State:
+        """
+        执行对话流
+        
+        Args:
+            state: 初始状态
+            
+        Returns:
+            最终状态
+        """
+        # TODO: 实现 LangGraph 调用
+        # 这里需要调用 LangGraph 的 graph.invoke
+        raise NotImplementedError("ChatFlow.invoke not yet implemented")
+    
+    async def stream(self, state: State):
+        """
+        流式执行对话流
+        
+        Args:
+            state: 初始状态
+            
+        Yields:
+            状态更新
+        """
+        # TODO: 实现 LangGraph 流式调用
+        raise NotImplementedError("ChatFlow.stream not yet implemented")
+
+
+def create_chatflow(
+    name: str,
+    agents: Optional[Dict[str, Any]] = None,
+    **kwargs
+) -> ChatFlow:
+    """创建对话流"""
+    return ChatFlow(name=name, agents=agents, **kwargs)
+

adk/client.py

@@ -0,0 +1,167 @@
+"""
+ADK 主客户端
+
+提供统一的客户端接口，使用 Builder 模式。
+"""
+
+from typing import Optional, Dict, Any
+from .core.config import ADKConfig
+from .memory import Memory
+from .chat import ChatAgent
+from .chatflow import ChatFlow
+from .workflow import WorkflowEngine
+from .knowledge import KnowledgeStore
+
+
+class ADKClient:
+    """
+    ADK 主客户端
+    
+    提供统一的接口访问所有 ADK 功能模块。
+    """
+    
+    def __init__(self, config: Optional[ADKConfig] = None):
+        """
+        初始化 ADK 客户端
+        
+        Args:
+            config: ADK 配置
+        """
+        self.config = config or ADKConfig()
+        
+        # 初始化各模块
+        self._memory: Optional[Memory] = None
+        self._knowledge_store: Optional[KnowledgeStore] = None
+    
+    @property
+    def memory(self) -> Memory:
+        """获取记忆模块"""
+        if self._memory is None and self.config.memory_enabled:
+            self._memory = Memory(
+                api_key=self.config.memory_api_key,
+                base_url=self.config.memory_base_url,
+            )
+        return self._memory
+    
+    def create_chat_agent(
+        self,
+        name: str,
+        **kwargs
+    ) -> ChatAgent:
+        """创建对话智能体"""
+        from .chat import create_chat_agent
+        return create_chat_agent(name=name, **kwargs)
+    
+    def create_chatflow(
+        self,
+        name: str,
+        **kwargs
+    ) -> ChatFlow:
+        """创建对话流"""
+        from .chatflow import create_chatflow
+        return create_chatflow(name=name, **kwargs)
+    
+    def create_workflow(
+        self,
+        name: str,
+        **kwargs
+    ) -> WorkflowEngine:
+        """创建工作流"""
+        from .workflow import create_workflow_engine
+        return create_workflow_engine(name=name, **kwargs)
+    
+    async def close(self):
+        """关闭客户端"""
+        if self._memory:
+            await self._memory.close()
+
+
+class ADKClientBuilder:
+    """ADK 客户端构建器"""
+    
+    def __init__(self):
+        self.config = ADKConfig()
+    
+    def with_llm(
+        self,
+        provider: str = "openai",
+        model: str = "gpt-4",
+        api_key: Optional[str] = None,
+        base_url: Optional[str] = None,
+        **kwargs
+    ) -> "ADKClientBuilder":
+        """配置 LLM"""
+        self.config.llm_provider = provider
+        self.config.llm_model = model
+        self.config.llm_api_key = api_key
+        self.config.llm_base_url = base_url
+        return self
+    
+    def with_memory(
+        self,
+        api_key: Optional[str] = None,
+        base_url: Optional[str] = None,
+        enabled: bool = True
+    ) -> "ADKClientBuilder":
+        """配置记忆"""
+        self.config.memory_enabled = enabled
+        self.config.memory_api_key = api_key
+        self.config.memory_base_url = base_url
+        return self
+    
+    def with_knowledge(
+        self,
+        store_type: str = "vector",
+        enabled: bool = True
+    ) -> "ADKClientBuilder":
+        """配置知识库"""
+        self.config.knowledge_enabled = enabled
+        self.config.knowledge_store_type = store_type
+        return self
+    
+    def with_http(
+        self,
+        timeout: float = 60.0,
+        max_retries: int = 3,
+        verify_ssl: bool = False
+    ) -> "ADKClientBuilder":
+        """配置 HTTP"""
+        self.config.http_timeout = timeout
+        self.config.http_max_retries = max_retries
+        self.config.http_verify_ssl = verify_ssl
+        return self
+    
+    def with_debug(self, enabled: bool = True) -> "ADKClientBuilder":
+        """配置调试模式"""
+        self.config.debug = enabled
+        self.config.log_level = "DEBUG" if enabled else "INFO"
+        return self
+    
+    def build(self) -> ADKClient:
+        """构建客户端"""
+        return ADKClient(config=self.config)
+
+
+def create_client(**kwargs) -> ADKClient:
+    """
+    创建 ADK 客户端（快捷方式）
+    
+    Args:
+        **kwargs: 配置参数
+        
+    Returns:
+        ADK 客户端实例
+    """
+    builder = ADKClientBuilder()
+    
+    if "llm_provider" in kwargs:
+        builder.with_llm(**{k.replace("llm_", ""): v for k, v in kwargs.items() if k.startswith("llm_")})
+    
+    if "memory_api_key" in kwargs:
+        builder.with_memory(**{k.replace("memory_", ""): v for k, v in kwargs.items() if k.startswith("memory_")})
+    
+    if "knowledge_store_type" in kwargs:
+        builder.with_knowledge(**{k.replace("knowledge_", ""): v for k, v in kwargs.items() if k.startswith("knowledge_")})
+    
+    return builder.build()
+

adk/core/__init__.py

@@ -0,0 +1,22 @@
+"""
+ADK Core - 核心功能模块
+
+提供基础抽象类、接口定义和通用工具。
+"""
+
+from .base import BaseAgent, BaseTool, BaseMemory
+from .config import ADKConfig, AgentConfig, ToolConfig
+from .types import State, Message, AgentResponse
+
+__all__ = [
+    "BaseAgent",
+    "BaseTool",
+    "BaseMemory",
+    "ADKConfig",
+    "AgentConfig",
+    "ToolConfig",
+    "State",
+    "Message",
+    "AgentResponse",
+]
+

adk/core/base.py

@@ -0,0 +1,85 @@
+"""
+ADK 基础抽象类
+
+定义智能体、工具、记忆等核心组件的抽象接口。
+"""
+
+from abc import ABC, abstractmethod
+from typing import Any, Dict, List, Optional
+from .types import State, Message, AgentResponse
+
+
+class BaseAgent(ABC):
+    """智能体基类"""
+    
+    def __init__(self, name: str, config: Optional[Dict[str, Any]] = None):
+        self.name = name
+        self.config = config or {}
+    
+    @abstractmethod
+    async def invoke(self, state: State) -> AgentResponse:
+        """
+        执行智能体逻辑
+        
+        Args:
+            state: 当前状态
+            
+        Returns:
+            智能体响应
+        """
+        pass
+    
+    @abstractmethod
+    def get_prompt(self) -> str:
+        """获取智能体的提示词"""
+        pass
+
+
+class BaseTool(ABC):
+    """工具基类"""
+    
+    def __init__(self, name: str, description: str, config: Optional[Dict[str, Any]] = None):
+        self.name = name
+        self.description = description
+        self.config = config or {}
+    
+    @abstractmethod
+    async def invoke(self, **kwargs) -> Any:
+        """
+        执行工具逻辑
+        
+        Args:
+            **kwargs: 工具参数
+            
+        Returns:
+            工具执行结果
+        """
+        pass
+    
+    @abstractmethod
+    def get_schema(self) -> Dict[str, Any]:
+        """获取工具的 JSON Schema"""
+        pass
+
+
+class BaseMemory(ABC):
+    """记忆基类"""
+    
+    def __init__(self, config: Optional[Dict[str, Any]] = None):
+        self.config = config or {}
+    
+    @abstractmethod
+    async def add(self, messages: List[Message], **kwargs) -> Dict[str, Any]:
+        """添加记忆"""
+        pass
+    
+    @abstractmethod
+    async def search(self, query: str, **kwargs) -> List[Dict[str, Any]]:
+        """搜索记忆"""
+        pass
+    
+    @abstractmethod
+    async def get(self, memory_id: str) -> Dict[str, Any]:
+        """获取记忆"""
+        pass
+

adk/core/config.py

@@ -0,0 +1,76 @@
+"""
+ADK 配置管理
+
+提供全局配置、智能体配置、工具配置等。
+"""
+
+from typing import Any, Dict, List, Optional
+from dataclasses import dataclass, field
+from pydantic import BaseModel, Field
+
+
+@dataclass
+class ADKConfig:
+    """ADK 全局配置"""
+    # LLM 配置
+    llm_provider: str = "openai"  # openai, anthropic, etc.
+    llm_model: str = "gpt-4"
+    llm_api_key: Optional[str] = None
+    llm_base_url: Optional[str] = None
+    llm_temperature: float = 0.7
+    llm_max_tokens: int = 2000
+    
+    # Memory 配置
+    memory_enabled: bool = True
+    memory_api_key: Optional[str] = None
+    memory_base_url: Optional[str] = None
+    
+    # Knowledge 配置
+    knowledge_enabled: bool = True
+    knowledge_store_type: str = "vector"  # vector, graph, hybrid
+    
+    # 工作流配置
+    workflow_timeout: float = 300.0
+    workflow_max_steps: int = 50
+    
+    # HTTP 配置
+    http_timeout: float = 60.0
+    http_max_retries: int = 3
+    http_verify_ssl: bool = False
+    
+    # 其他配置
+    debug: bool = False
+    log_level: str = "INFO"
+    
+    def to_dict(self) -> Dict[str, Any]:
+        """转换为字典"""
+        return {
+            k: v for k, v in self.__dict__.items()
+            if not k.startswith("_")
+        }
+
+
+@dataclass
+class AgentConfig:
+    """智能体配置"""
+    name: str
+    description: str
+    prompt_template: Optional[str] = None
+    tools: List[str] = field(default_factory=list)
+    memory_enabled: bool = True
+    temperature: Optional[float] = None
+    max_tokens: Optional[int] = None
+    metadata: Dict[str, Any] = field(default_factory=dict)
+
+
+@dataclass
+class ToolConfig:
+    """工具配置"""
+    name: str
+    description: str
+    schema: Dict[str, Any]
+    enabled: bool = True
+    timeout: float = 30.0
+    max_retries: int = 3
+    metadata: Dict[str, Any] = field(default_factory=dict)
+

adk/core/types.py

@@ -0,0 +1,90 @@
+"""
+ADK 类型定义
+
+定义状态、消息、响应等核心数据类型。
+"""
+
+from typing import Any, Dict, List, Optional, Union
+from dataclasses import dataclass, field
+from datetime import datetime
+from enum import Enum
+
+
+class MessageRole(str, Enum):
+    """消息角色"""
+    USER = "user"
+    ASSISTANT = "assistant"
+    SYSTEM = "system"
+    TOOL = "tool"
+
+
+@dataclass
+class Message:
+    """消息对象"""
+    role: MessageRole
+    content: str
+    name: Optional[str] = None
+    tool_calls: Optional[List[Dict[str, Any]]] = None
+    tool_call_id: Optional[str] = None
+    metadata: Dict[str, Any] = field(default_factory=dict)
+    timestamp: datetime = field(default_factory=datetime.now)
+    
+    def to_dict(self) -> Dict[str, Any]:
+        """转换为字典"""
+        return {
+            "role": self.role.value,
+            "content": self.content,
+            "name": self.name,
+            "tool_calls": self.tool_calls,
+            "tool_call_id": self.tool_call_id,
+            "metadata": self.metadata,
+            "timestamp": self.timestamp.isoformat(),
+        }
+    
+    @classmethod
+    def from_dict(cls, data: Dict[str, Any]) -> "Message":
+        """从字典创建"""
+        return cls(
+            role=MessageRole(data["role"]),
+            content=data["content"],
+            name=data.get("name"),
+            tool_calls=data.get("tool_calls"),
+            tool_call_id=data.get("tool_call_id"),
+            metadata=data.get("metadata", {}),
+            timestamp=datetime.fromisoformat(data.get("timestamp", datetime.now().isoformat())),
+        )
+
+
+@dataclass
+class State:
+    """状态对象（用于工作流）"""
+    messages: List[Message] = field(default_factory=list)
+    context: Dict[str, Any] = field(default_factory=dict)
+    metadata: Dict[str, Any] = field(default_factory=dict)
+    next: Optional[str] = None
+    
+    def update(self, **kwargs) -> "State":
+        """更新状态"""
+        for key, value in kwargs.items():
+            if hasattr(self, key):
+                setattr(self, key, value)
+        return self
+
+
+@dataclass
+class AgentResponse:
+    """智能体响应"""
+    content: str
+    tool_calls: Optional[List[Dict[str, Any]]] = None
+    metadata: Dict[str, Any] = field(default_factory=dict)
+    state: Optional[State] = None
+    
+    def to_message(self, role: MessageRole = MessageRole.ASSISTANT) -> Message:
+        """转换为消息"""
+        return Message(
+            role=role,
+            content=self.content,
+            tool_calls=self.tool_calls,
+            metadata=self.metadata,
+        )
+

adk/http/__init__.py

@@ -0,0 +1,22 @@
+"""
+ADK HTTP Transport Layer
+
+提供 HTTP 传输层，包括连接池、重试、熔断等功能。
+"""
+
+from .client import HTTPClient, create_http_client
+from .pool import ConnectionPool, ConnectionConfig
+from .circuit_breaker import CircuitBreaker, CircuitBreakerConfig
+from .retry import RetryConfig, RetryHandler
+
+__all__ = [
+    "HTTPClient",
+    "create_http_client",
+    "ConnectionPool",
+    "ConnectionConfig",
+    "CircuitBreaker",
+    "CircuitBreakerConfig",
+    "RetryConfig",
+    "RetryHandler",
+]
+