feat: add aiprovider service foundation

2026-04-07 17:30:27 +08:00
parent 3f5505f03e
commit 9a50e72bd1
42 changed files with 1766 additions and 166 deletions
--- a/aiprovider/.env.example
+++ b/aiprovider/.env.example
@@ -0,0 +1,34 @@
+# Shared service settings
+SERVICE_NAME=planet-ai-provider
+SERVICE_VERSION=0.1.0
+AI_PROVIDER_SERVICE_TOKEN=change_me
+AI_TIMEOUT_SECONDS=60
+AI_HTTP_RETRY_ATTEMPTS=2
+AI_ANALYSIS_SYSTEM_PROMPT=你是态势感知分析助手。请基于输入的上下文、观测与约束，输出结构化、克制、可执行的分析。
+
+# Select one provider mode:
+# - openai_compatible
+# - claude_compatible
+# - ollama
+AI_PROVIDER=ollama
+
+# Common model selection
+AI_MODEL=qwen2.5:7b
+
+# OpenAI-compatible example (vLLM / LM Studio / One API / local gateway)
+# AI_PROVIDER=openai_compatible
+# AI_BASE_URL=http://127.0.0.1:8001/v1
+# AI_API_KEY=local-key
+
+# Claude-compatible example (Anthropic / MiniMax / Claude-compatible gateway)
+# AI_PROVIDER=claude_compatible
+# AI_BASE_URL=http://127.0.0.1:8002
+# AI_API_KEY=local-key
+# AI_MAX_TOKENS=1200
+# AI_ANTHROPIC_VERSION=2023-06-01
+
+# Ollama native example
+AI_BASE_URL=http://127.0.0.1:11434
+AI_API_KEY=
+AI_MAX_TOKENS=1200
+AI_ANTHROPIC_VERSION=2023-06-01
--- a/aiprovider/Dockerfile
+++ b/aiprovider/Dockerfile
@@ -0,0 +1,23 @@
+FROM python:3.14-slim
+
+COPY --from=ghcr.io/astral-sh/uv:latest /uv /uvx /bin/
+
+WORKDIR /app
+
+ENV PYTHONDONTWRITEBYTECODE=1
+ENV PYTHONUNBUFFERED=1
+ENV UV_COMPILE_BYTECODE=1
+ENV UV_LINK_MODE=copy
+
+RUN apt-get update && apt-get install -y --no-install-recommends \
+    curl \
+    && rm -rf /var/lib/apt/lists/*
+
+COPY pyproject.toml uv.lock /app/
+RUN uv sync --frozen --no-dev
+
+COPY . /app
+
+EXPOSE 8010
+
+CMD ["uv", "run", "--frozen", "--no-dev", "--project", "/app", "python", "-m", "uvicorn", "aiprovider.main:app", "--host", "0.0.0.0", "--port", "8010", "--reload"]
--- a/aiprovider/README.md
+++ b/aiprovider/README.md
@@ -0,0 +1,81 @@
+# AI Provider Service
+
+`aiprovider` 是独立的模型适配服务，负责把项目内部的分析请求转发到具体的大模型供应商。
+
+完整使用说明见:
+
+- [docs/aiprovider.md](/home/ray/dev/linkong/planet/docs/aiprovider.md)
+
+当前支持:
+
+- `AI_PROVIDER=openai`
+- `AI_PROVIDER=openai_compatible`
+- `AI_PROVIDER=anthropic`
+- `AI_PROVIDER=anthropic_compatible`
+- `AI_PROVIDER=claude_compatible`
+- `AI_PROVIDER=ollama`
+
+典型配置:
+
+```env
+AI_PROVIDER=openai_compatible
+AI_BASE_URL=https://api.openai.com/v1
+AI_API_KEY=your_api_key
+AI_MODEL=gpt-4o-mini
+AI_TIMEOUT_SECONDS=60
+AI_PROVIDER_SERVICE_TOKEN=change_me
+```
+
+Claude 兼容供应商示例:
+
+```env
+AI_PROVIDER=claude_compatible
+AI_BASE_URL=https://your-claude-compatible-endpoint.example.com
+AI_API_KEY=your_api_key
+AI_MODEL=your-claude-compatible-model
+AI_TIMEOUT_SECONDS=60
+AI_MAX_TOKENS=1200
+AI_ANTHROPIC_VERSION=2023-06-01
+AI_PROVIDER_SERVICE_TOKEN=change_me
+```
+
+适用场景:
+
+- Anthropic 官方 Claude API
+- Claude 兼容网关
+- MiniMax 等提供 Claude/Anthropic 风格消息接口的服务
+
+Ollama 原生示例:
+
+```env
+AI_PROVIDER=ollama
+AI_BASE_URL=http://127.0.0.1:11434
+AI_API_KEY=
+AI_MODEL=qwen2.5:7b
+AI_TIMEOUT_SECONDS=60
+AI_PROVIDER_SERVICE_TOKEN=change_me
+```
+
+本地模型接入建议:
+
+- `vLLM`、`LM Studio`、`One API`：优先使用 `openai_compatible`
+- `MiniMax`、Claude 兼容网关：使用 `claude_compatible`
+- `Ollama`：可直接使用 `ollama`
+
+启动模板:
+
+- `aiprovider/.env.example`
+- `docker-compose.local-model.yml`
+
+跨服务调用补充:
+
+- 业务服务优先调用主后端 `/api/v1/ai/...`
+- 直接调用 `aiprovider` 时使用 `X-Provider-Token`
+- 支持 `X-Request-ID` 透传
+- 内置轻量重试，适合跨机器 HTTP RPC 场景
+
+接口:
+
+- `GET /health`
+- `GET /v1/provider/status`
+- `POST /v1/analyze`
--- a/aiprovider/init.py
+++ b/aiprovider/init.py
@@ -0,0 +1 @@
+"""AI provider adapter service package."""
--- a/aiprovider/config.py
+++ b/aiprovider/config.py
@@ -0,0 +1,35 @@
+from functools import lru_cache
+from pathlib import Path
+
+from pydantic_settings import BaseSettings
+
+
+class Settings(BaseSettings):
+    SERVICE_NAME: str = "planet-ai-provider"
+    SERVICE_VERSION: str = "0.1.0"
+
+    AI_PROVIDER: str = "disabled"
+    AI_BASE_URL: str = "https://api.openai.com/v1"
+    AI_API_KEY: str = ""
+    AI_MODEL: str = ""
+    AI_TIMEOUT_SECONDS: int = 60
+    AI_HTTP_RETRY_ATTEMPTS: int = 2
+    AI_MAX_TOKENS: int = 1200
+    AI_ANTHROPIC_VERSION: str = "2023-06-01"
+    AI_ANALYSIS_SYSTEM_PROMPT: str = (
+        "你是态势感知分析助手。请基于输入的上下文、观测与约束，输出结构化、克制、可执行的分析。"
+    )
+
+    AI_PROVIDER_SERVICE_TOKEN: str = ""
+
+    class Config:
+        env_file = Path(__file__).parent / ".env"
+        case_sensitive = True
+
+
+@lru_cache()
+def get_settings() -> Settings:
+    return Settings()
+
+
+settings = get_settings()
--- a/aiprovider/main.py
+++ b/aiprovider/main.py
@@ -0,0 +1,79 @@
+from uuid import uuid4
+
+from fastapi import Depends, FastAPI, Header, HTTPException, Request, Response, status
+
+from aiprovider.config import settings
+from aiprovider.provider_service import ProviderService
+from aiprovider.schemas import (
+    AIProviderStatusResponse,
+    SituationalAnalysisRequest,
+    SituationalAnalysisResponse,
+)
+
+app = FastAPI(
+    title=settings.SERVICE_NAME,
+    version=settings.SERVICE_VERSION,
+    description="AI provider adapter service for Planet",
+)
+
+
+@app.middleware("http")
+async def request_id_middleware(request: Request, call_next):
+    request_id = request.headers.get("X-Request-ID") or str(uuid4())
+    request.state.request_id = request_id
+    response = await call_next(request)
+    response.headers["X-Request-ID"] = request_id
+    return response
+
+
+def verify_service_token(x_provider_token: str | None = Header(default=None)) -> None:
+    expected = settings.AI_PROVIDER_SERVICE_TOKEN
+    if not expected:
+        return
+    if x_provider_token != expected:
+        raise HTTPException(
+            status_code=status.HTTP_401_UNAUTHORIZED,
+            detail="Invalid provider service token",
+        )
+
+
+def get_provider_service() -> ProviderService:
+    return ProviderService()
+
+
+@app.get("/health")
+async def health_check():
+    return {
+        "status": "healthy",
+        "service": settings.SERVICE_NAME,
+        "version": settings.SERVICE_VERSION,
+    }
+
+
+@app.get(
+    "/v1/provider/status",
+    response_model=AIProviderStatusResponse,
+    dependencies=[Depends(verify_service_token)],
+)
+async def get_provider_status(
+    response: Response,
+    request: Request,
+    provider_service: ProviderService = Depends(get_provider_service),
+):
+    response.headers["X-Request-ID"] = request.state.request_id
+    return provider_service.get_status()
+
+
+@app.post(
+    "/v1/analyze",
+    response_model=SituationalAnalysisResponse,
+    dependencies=[Depends(verify_service_token)],
+)
+async def analyze(
+    payload: SituationalAnalysisRequest,
+    response: Response,
+    request: Request,
+    provider_service: ProviderService = Depends(get_provider_service),
+):
+    response.headers["X-Request-ID"] = request.state.request_id
+    return await provider_service.analyze(payload)
--- a/aiprovider/provider_service.py
+++ b/aiprovider/provider_service.py
@@ -0,0 +1,240 @@
+from __future__ import annotations
+
+import asyncio
+from typing import Any
+
+import httpx
+from fastapi import HTTPException, status
+
+from aiprovider.config import settings
+from aiprovider.schemas import (
+    AIProviderStatusResponse,
+    SituationalAnalysisRequest,
+    SituationalAnalysisResponse,
+)
+
+
+def _normalize_provider(value: str) -> str:
+    return (value or "disabled").strip().lower()
+
+
+class ProviderService:
+    def __init__(self) -> None:
+        self.provider = _normalize_provider(settings.AI_PROVIDER)
+        self.base_url = settings.AI_BASE_URL.rstrip("/")
+        self.api_key = settings.AI_API_KEY
+        self.default_model = settings.AI_MODEL
+        self.timeout = settings.AI_TIMEOUT_SECONDS
+        self.http_retry_attempts = max(settings.AI_HTTP_RETRY_ATTEMPTS, 1)
+        self.max_tokens = settings.AI_MAX_TOKENS
+        self.anthropic_version = settings.AI_ANTHROPIC_VERSION
+        self.system_prompt = settings.AI_ANALYSIS_SYSTEM_PROMPT
+
+    def get_status(self) -> AIProviderStatusResponse:
+        enabled = self.provider != "disabled"
+        configured = enabled and bool(self.base_url and self.api_key and self.default_model)
+        return AIProviderStatusResponse(
+            provider=self.provider,
+            enabled=enabled,
+            configured=configured,
+            model=self.default_model or None,
+            base_url=self.base_url if enabled else None,
+        )
+
+    async def analyze(self, payload: SituationalAnalysisRequest) -> SituationalAnalysisResponse:
+        if self.provider == "disabled":
+            raise HTTPException(
+                status_code=status.HTTP_503_SERVICE_UNAVAILABLE,
+                detail="AI provider is disabled. Configure AI_PROVIDER in .env to enable analysis.",
+            )
+
+        model = payload.preferred_model or self.default_model
+        if not self.base_url or not self.api_key or not model:
+            raise HTTPException(
+                status_code=status.HTTP_503_SERVICE_UNAVAILABLE,
+                detail="AI provider is not fully configured. Check AI_BASE_URL, AI_API_KEY, and AI_MODEL.",
+            )
+
+        prompt = self._build_prompt(payload)
+
+        if self.provider in {"openai", "openai_compatible"}:
+            data = await self._request_openai_compatible(model, prompt)
+            content = self._extract_openai_content(data)
+        elif self.provider in {"anthropic", "anthropic_compatible", "claude_compatible"}:
+            data = await self._request_anthropic_compatible(model, prompt)
+            content = self._extract_anthropic_content(data)
+        elif self.provider == "ollama":
+            data = await self._request_ollama(model, prompt)
+            content = self._extract_ollama_content(data)
+        else:
+            raise HTTPException(
+                status_code=status.HTTP_400_BAD_REQUEST,
+                detail=f"Unsupported AI provider: {self.provider}",
+            )
+
+        return SituationalAnalysisResponse(
+            provider=self.provider,
+            model=model,
+            content=content,
+            raw_response=data,
+        )
+
+    def _build_prompt(self, payload: SituationalAnalysisRequest) -> str:
+        sections = [
+            f"任务标题:\n{payload.title}",
+            f"分析目标:\n{payload.objective}",
+        ]
+        if payload.observations:
+            sections.append("观测事实:\n" + "\n".join(f"- {item}" for item in payload.observations))
+        if payload.constraints:
+            sections.append("约束条件:\n" + "\n".join(f"- {item}" for item in payload.constraints))
+        if payload.context:
+            sections.append(f"附加上下文:\n{payload.context}")
+        sections.append(
+            "请输出: 1) 态势摘要 2) 关键风险 3) 研判依据 4) 建议动作 5) 还缺少的数据。"
+        )
+        return "\n\n".join(sections)
+
+    async def _request_openai_compatible(self, model: str, prompt: str) -> dict[str, Any]:
+        request_body = {
+            "model": model,
+            "messages": [
+                {"role": "system", "content": self.system_prompt},
+                {"role": "user", "content": prompt},
+            ],
+            "temperature": 0.2,
+        }
+        return await self._post(
+            path="/chat/completions",
+            headers={
+                "Authorization": f"Bearer {self.api_key}",
+                "Content-Type": "application/json",
+            },
+            request_body=request_body,
+        )
+
+    async def _request_anthropic_compatible(self, model: str, prompt: str) -> dict[str, Any]:
+        request_body = {
+            "model": model,
+            "system": self.system_prompt,
+            "messages": [
+                {
+                    "role": "user",
+                    "content": [
+                        {
+                            "type": "text",
+                            "text": prompt,
+                        }
+                    ],
+                }
+            ],
+            "max_tokens": self.max_tokens,
+            "temperature": 0.2,
+        }
+        return await self._post(
+            path="/messages",
+            headers={
+                "x-api-key": self.api_key,
+                "anthropic-version": self.anthropic_version,
+                "Content-Type": "application/json",
+            },
+            request_body=request_body,
+        )
+
+    async def _request_ollama(self, model: str, prompt: str) -> dict[str, Any]:
+        request_body = {
+            "model": model,
+            "stream": False,
+            "system": self.system_prompt,
+            "prompt": prompt,
+            "options": {
+                "temperature": 0.2,
+            },
+        }
+        return await self._post(
+            path="/api/generate",
+            headers={
+                "Content-Type": "application/json",
+            },
+            request_body=request_body,
+        )
+
+    async def _post(
+        self,
+        path: str,
+        headers: dict[str, str],
+        request_body: dict[str, Any],
+    ) -> dict[str, Any]:
+        last_error: Exception | None = None
+        for attempt in range(1, self.http_retry_attempts + 1):
+            try:
+                async with httpx.AsyncClient(timeout=self.timeout) as client:
+                    response = await client.post(
+                        f"{self.base_url}{path}",
+                        headers=headers,
+                        json=request_body,
+                    )
+                    response.raise_for_status()
+                    return response.json()
+            except httpx.HTTPStatusError as exc:
+                last_error = exc
+                if attempt < self.http_retry_attempts and exc.response.status_code >= 500:
+                    await asyncio.sleep(0.3 * attempt)
+                    continue
+                detail = exc.response.text or "AI provider returned an error"
+                raise HTTPException(
+                    status_code=status.HTTP_502_BAD_GATEWAY,
+                    detail=f"AI provider request failed: {detail}",
+                ) from exc
+            except httpx.HTTPError as exc:
+                last_error = exc
+                if attempt < self.http_retry_attempts:
+                    await asyncio.sleep(0.3 * attempt)
+                    continue
+                raise HTTPException(
+                    status_code=status.HTTP_502_BAD_GATEWAY,
+                    detail=f"Failed to reach AI provider: {exc}",
+                ) from exc
+
+        raise HTTPException(
+            status_code=status.HTTP_502_BAD_GATEWAY,
+            detail=f"AI provider request failed: {last_error}",
+        )
+
+    def _extract_openai_content(self, payload: dict[str, Any]) -> str:
+        choices = payload.get("choices") or []
+        if not choices:
+            return ""
+
+        message = choices[0].get("message") or {}
+        content = message.get("content")
+        if isinstance(content, str):
+            return content
+        if isinstance(content, list):
+            return "".join(
+                item.get("text", "")
+                for item in content
+                if isinstance(item, dict)
+            )
+        return ""
+
+    def _extract_anthropic_content(self, payload: dict[str, Any]) -> str:
+        content = payload.get("content")
+        if isinstance(content, str):
+            return content
+        if not isinstance(content, list):
+            return ""
+
+        fragments: list[str] = []
+        for item in content:
+            if not isinstance(item, dict):
+                continue
+            if item.get("type") == "text" and isinstance(item.get("text"), str):
+                fragments.append(item["text"])
+        return "".join(fragments)
+
+    def _extract_ollama_content(self, payload: dict[str, Any]) -> str:
+        response = payload.get("response")
+        if isinstance(response, str):
+            return response
+        return ""
--- a/aiprovider/schemas.py
+++ b/aiprovider/schemas.py
@@ -0,0 +1,27 @@
+from typing import Any
+
+from pydantic import BaseModel, Field
+
+
+class SituationalAnalysisRequest(BaseModel):
+    title: str = Field(..., min_length=1, max_length=200)
+    objective: str = Field(..., min_length=1, max_length=1000)
+    context: dict[str, Any] = Field(default_factory=dict)
+    observations: list[str] = Field(default_factory=list)
+    constraints: list[str] = Field(default_factory=list)
+    preferred_model: str | None = Field(default=None, max_length=200)
+
+
+class SituationalAnalysisResponse(BaseModel):
+    provider: str
+    model: str
+    content: str
+    raw_response: dict[str, Any] = Field(default_factory=dict)
+
+
+class AIProviderStatusResponse(BaseModel):
+    provider: str
+    enabled: bool
+    configured: bool
+    model: str | None = None
+    base_url: str | None = None