提交 cc32bf75 authored 作者: caifuming's avatar caifuming

cfm_7/14完善AI服务第二版

上级 97528101
__pycache__/
*.pyc
.venv/
.env
.pytest_cache/
\ No newline at end of file
# ai-service - 实习生训练平台 AI 服务
FastAPI + Milvus 风格的 AI 服务骨架。
## 启动
```bash
# 安装依赖
pip install -r requirements.txt
# 开发模式(7083 端口)
uvicorn app.main:app --host 0.0.0.0 --port 7083 --reload
# 或直接运行
python -m app.main
```
## 端口
默认 7083,供 backend-app 反向代理调用。
\ No newline at end of file
"""Structured call logging."""
from __future__ import annotations
import json
import logging
from typing import Any
LOGGER = logging.getLogger("app.ai_calling")
class CallLogger:
"""Emit JSON logs for AI calls."""
def log(self, payload: dict[str, Any]) -> None:
LOGGER.info(json.dumps(payload, ensure_ascii=True, sort_keys=True))
"""Error codes and service exceptions."""
from __future__ import annotations
INVALID_REQUEST = "INVALID_REQUEST"
PROMPT_NOT_FOUND = "PROMPT_NOT_FOUND"
PROMPT_VARIABLE_MISSING = "PROMPT_VARIABLE_MISSING"
MODEL_NOT_CONFIGURED = "MODEL_NOT_CONFIGURED"
MODEL_AUTH_FAILED = "MODEL_AUTH_FAILED"
MODEL_TIMEOUT = "MODEL_TIMEOUT"
MODEL_RATE_LIMITED = "MODEL_RATE_LIMITED"
MODEL_UNAVAILABLE = "MODEL_UNAVAILABLE"
MODEL_INVALID_RESPONSE = "MODEL_INVALID_RESPONSE"
ALL_PROVIDERS_FAILED = "ALL_PROVIDERS_FAILED"
class AIServiceError(Exception):
"""Structured service error."""
def __init__(self, code: str, message: str, retryable: bool = False) -> None:
super().__init__(message)
self.code = code
self.message = message
self.retryable = retryable
"""Response builders for failure and fallback paths."""
from __future__ import annotations
from app.ai_calling.schemas import AIChatResponse, AIResponseData, AIResponseError
DEFAULT_FALLBACK_MESSAGE = "AI service is temporarily unavailable. Please retry or switch to manual review."
def build_error_response(
*,
request_id: str,
trace_id: str,
prompt_name: str | None,
prompt_version: str | None,
error_code: str,
error_message: str,
fallback: bool,
provider: str | None = None,
model: str | None = None,
content: str = "",
) -> AIChatResponse:
return AIChatResponse(
success=False,
data=AIResponseData(content=content, structured=None),
provider=provider,
model=model,
fallback=fallback,
request_id=request_id,
trace_id=trace_id,
prompt_name=prompt_name,
prompt_version=prompt_version,
error=AIResponseError(code=error_code, message=error_message),
)
def build_fallback_response(
*,
request_id: str,
trace_id: str,
prompt_name: str | None,
prompt_version: str | None,
error_code: str,
error_message: str,
) -> AIChatResponse:
return build_error_response(
request_id=request_id,
trace_id=trace_id,
prompt_name=prompt_name,
prompt_version=prompt_version,
error_code=error_code,
error_message=error_message,
fallback=True,
content=DEFAULT_FALLBACK_MESSAGE,
)
"""In-memory health tracker."""
from __future__ import annotations
class AIServiceHealthTracker:
def __init__(self, failure_threshold: int = 3) -> None:
self._failure_threshold = max(1, failure_threshold)
self._consecutive_failures = 0
def record_success(self) -> None:
self._consecutive_failures = 0
def record_failure(self) -> None:
self._consecutive_failures += 1
@property
def unhealthy(self) -> bool:
return self._consecutive_failures >= self._failure_threshold
@property
def consecutive_failures(self) -> int:
return self._consecutive_failures
"""In-memory rate limiter for MVP."""
from __future__ import annotations
import asyncio
import time
from collections import deque
from app.ai_calling.errors import MODEL_RATE_LIMITED, AIServiceError
class InMemoryRateLimiter:
"""Simple fixed-window rate limiter."""
def __init__(self, max_requests: int, period_seconds: float = 1.0) -> None:
self._max_requests = max_requests
self._period_seconds = period_seconds
self._lock = asyncio.Lock()
self._timestamps: deque[float] = deque()
async def acquire(self) -> None:
if self._max_requests <= 0:
return
now = time.monotonic()
async with self._lock:
while self._timestamps and now - self._timestamps[0] >= self._period_seconds:
self._timestamps.popleft()
if len(self._timestamps) >= self._max_requests:
raise AIServiceError(
MODEL_RATE_LIMITED,
"AI request rate limit exceeded.",
)
self._timestamps.append(now)
"""Pydantic schemas for the AI calling layer."""
from __future__ import annotations
from typing import Any, Literal
from pydantic import BaseModel, ConfigDict, Field
class AIChatRequest(BaseModel):
model_config = ConfigDict(extra="forbid")
task: str = Field(default="chat")
provider: str | None = Field(default=None)
model: str | None = Field(default=None)
fallback_provider: str | None = Field(default=None)
fallback_model: str | None = Field(default=None)
prompt_name: str
variables: dict[str, Any] = Field(default_factory=dict)
response_format: Literal["text", "json"] = Field(default="text")
temperature: float = Field(default=0.2, ge=0.0, le=2.0)
timeout_seconds: float = Field(default=6.0, gt=0.0, le=8.0)
trace_id: str | None = Field(default=None)
class AIResponseData(BaseModel):
content: str
structured: Any | None = None
class AIResponseError(BaseModel):
code: str
message: str
class AIChatResponse(BaseModel):
success: bool
data: AIResponseData
provider: str | None = None
model: str | None = None
fallback: bool = False
request_id: str
trace_id: str
prompt_name: str | None = None
prompt_version: str | None = None
error: AIResponseError | None = None
差异被折叠。
"""AI chat API routes."""
from fastapi import APIRouter
from app.ai_calling.schemas import AIChatRequest, AIChatResponse
from app.ai_calling.service import get_ai_service
router = APIRouter()
@router.post("/chat", response_model=AIChatResponse)
async def chat(req: AIChatRequest) -> AIChatResponse:
"""Unified LLM chat entrypoint."""
service = get_ai_service()
return await service.chat(req)
"""LLM provider package."""
"""Shared provider contracts."""
from __future__ import annotations
from abc import ABC, abstractmethod
from dataclasses import dataclass
from typing import Any
@dataclass(frozen=True, slots=True)
class ChatMessage:
role: str
content: str
@dataclass(frozen=True, slots=True)
class ProviderRequest:
model: str
messages: list[ChatMessage]
temperature: float
response_format: str
timeout_seconds: float
trace_id: str
@dataclass(frozen=True, slots=True)
class ProviderResult:
content: str
structured: Any | None = None
raw: dict[str, Any] | None = None
class LLMProvider(ABC):
"""Provider interface for model backends."""
name: str
@abstractmethod
async def chat(self, request: ProviderRequest) -> ProviderResult:
"""Execute a chat completion request."""
"""Provider factory."""
from __future__ import annotations
from dataclasses import dataclass
from app.ai_calling.errors import MODEL_NOT_CONFIGURED, AIServiceError
from app.llm.base import LLMProvider
from app.llm.mock import MockProvider
from app.llm.openai import OpenAIProvider
@dataclass(frozen=True, slots=True)
class ProviderFactoryConfig:
openai_api_key: str | None
openai_base_url: str
openai_organization: str | None = None
class ProviderFactory:
"""Create provider implementations by name."""
def __init__(self, config: ProviderFactoryConfig) -> None:
self._config = config
def create(self, provider_name: str) -> LLMProvider:
normalized = provider_name.strip().lower()
if normalized == "mock":
return MockProvider()
if normalized == "openai":
return OpenAIProvider(
api_key=self._config.openai_api_key,
base_url=self._config.openai_base_url,
organization=self._config.openai_organization,
)
raise AIServiceError(
MODEL_NOT_CONFIGURED,
f"Provider '{provider_name}' is not supported.",
)
"""Mock provider for local verification."""
from __future__ import annotations
import json
from app.llm.base import LLMProvider, ProviderRequest, ProviderResult
class MockProvider(LLMProvider):
name = "mock"
async def chat(self, request: ProviderRequest) -> ProviderResult:
user_message = next(
(message.content for message in reversed(request.messages) if message.role == "user"),
"",
)
content = f"[mock:{request.model}] {user_message[:400]}".strip()
structured = None
if request.response_format == "json":
structured = {
"provider": self.name,
"model": request.model,
"echo": user_message[:400],
}
content = json.dumps(structured, ensure_ascii=True)
return ProviderResult(
content=content,
structured=structured,
raw={"provider": self.name, "model": request.model},
)
"""OpenAI-compatible provider implementation."""
from __future__ import annotations
from typing import Any
import httpx
from app.ai_calling.errors import (
MODEL_AUTH_FAILED,
MODEL_INVALID_RESPONSE,
MODEL_NOT_CONFIGURED,
MODEL_RATE_LIMITED,
MODEL_TIMEOUT,
MODEL_UNAVAILABLE,
AIServiceError,
)
from app.llm.base import LLMProvider, ProviderRequest, ProviderResult
class OpenAIProvider(LLMProvider):
name = "openai"
def __init__(self, api_key: str | None, base_url: str, organization: str | None = None) -> None:
self._api_key = api_key
self._base_url = base_url.rstrip("/")
self._organization = organization
async def chat(self, request: ProviderRequest) -> ProviderResult:
if not self._api_key:
raise AIServiceError(
MODEL_NOT_CONFIGURED,
"OPENAI_API_KEY is not configured.",
)
payload: dict[str, Any] = {
"model": request.model,
"messages": [
{"role": message.role, "content": message.content}
for message in request.messages
],
"temperature": request.temperature,
}
if request.response_format == "json":
payload["response_format"] = {"type": "json_object"}
headers = {
"Authorization": f"Bearer {self._api_key}",
"Content-Type": "application/json",
}
if self._organization:
headers["OpenAI-Organization"] = self._organization
try:
async with httpx.AsyncClient(timeout=request.timeout_seconds) as client:
response = await client.post(
f"{self._base_url}/chat/completions",
json=payload,
headers=headers,
)
except httpx.TimeoutException as exc:
raise AIServiceError(
MODEL_TIMEOUT,
"Model request timed out.",
retryable=True,
) from exc
except httpx.HTTPError as exc:
raise AIServiceError(
MODEL_UNAVAILABLE,
f"Provider request failed: {exc.__class__.__name__}",
retryable=True,
) from exc
if response.status_code in (401, 403):
raise AIServiceError(
MODEL_AUTH_FAILED,
"Provider authentication failed.",
)
if response.status_code == 429:
raise AIServiceError(
MODEL_RATE_LIMITED,
"Provider rate limit reached.",
retryable=True,
)
if response.status_code >= 500:
raise AIServiceError(
MODEL_UNAVAILABLE,
f"Provider returned status {response.status_code}.",
retryable=True,
)
if response.status_code >= 400:
raise AIServiceError(
MODEL_UNAVAILABLE,
f"Provider returned status {response.status_code}.",
)
body = response.json()
try:
content = body["choices"][0]["message"]["content"]
except (KeyError, IndexError, TypeError) as exc:
raise AIServiceError(
MODEL_INVALID_RESPONSE,
"Provider response format is invalid.",
) from exc
return ProviderResult(
content=content or "",
raw=body,
)
...@@ -16,10 +16,11 @@ app.add_middleware( ...@@ -16,10 +16,11 @@ app.add_middleware(
allow_headers=["*"], allow_headers=["*"],
) )
from app.api import health, knowledge # noqa: E402 from app.api import ai, health, knowledge # noqa: E402
app.include_router(health.router, prefix="/api/health", tags=["health"]) app.include_router(health.router, prefix="/api/health", tags=["health"])
app.include_router(knowledge.router, prefix="/api/knowledge", tags=["knowledge"]) app.include_router(knowledge.router, prefix="/api/knowledge", tags=["knowledge"])
app.include_router(ai.router, prefix="/api/v1/ai", tags=["ai"])
if __name__ == "__main__": if __name__ == "__main__":
......
"""Prompt management package."""
"""Prompt template loading and rendering."""
from __future__ import annotations
from dataclasses import dataclass
from pathlib import Path
from typing import Any
import yaml
from app.ai_calling.errors import PROMPT_NOT_FOUND, AIServiceError
from app.llm.base import ChatMessage
from app.prompt.validator import (
extract_template_variables,
validate_prompt_definition,
validate_prompt_variables,
)
@dataclass(frozen=True, slots=True)
class PromptTemplate:
name: str
version: str
system: str
user: str
required_variables: set[str]
class PromptLoader:
"""Load prompt templates from YAML files."""
def __init__(self, templates_dir: Path | None = None) -> None:
self._templates_dir = templates_dir or Path(__file__).resolve().parent / "templates"
self._cache: dict[str, PromptTemplate] = {}
def load(self, prompt_name: str) -> PromptTemplate:
if prompt_name in self._cache:
return self._cache[prompt_name]
path = self._templates_dir / f"{prompt_name}.yaml"
if not path.exists():
raise AIServiceError(
PROMPT_NOT_FOUND,
f"Prompt template '{prompt_name}' was not found.",
)
data = yaml.safe_load(path.read_text(encoding="utf-8")) or {}
validate_prompt_definition(data)
required_variables = set(data.get("required_variables") or [])
required_variables |= extract_template_variables(data["system"])
required_variables |= extract_template_variables(data["user"])
template = PromptTemplate(
name=str(data["name"]),
version=str(data["version"]),
system=str(data["system"]),
user=str(data["user"]),
required_variables=required_variables,
)
self._cache[prompt_name] = template
return template
def render_messages(
self,
template: PromptTemplate,
variables: dict[str, Any],
) -> list[ChatMessage]:
validate_prompt_variables(template.required_variables, variables)
formatted_variables = {key: self._stringify_value(value) for key, value in variables.items()}
return [
ChatMessage(role="system", content=template.system.format(**formatted_variables)),
ChatMessage(role="user", content=template.user.format(**formatted_variables)),
]
@staticmethod
def _stringify_value(value: Any) -> str:
if isinstance(value, str):
return value
if value is None:
return ""
return str(value)
name: knowledge_extract_v1
version: v1
required_variables:
- project_name
- project_content
system: |
You extract learnable knowledge points for intern training materials.
Prefer structured and reviewable output over creative writing.
user: |
Project: {project_name}
Source content:
{project_content}
Return:
1. Knowledge points
2. Prerequisites
3. Suggested study order
4. Common mistakes
name: recommend_v1
version: v1
required_variables:
- project_name
- project_context
system: |
You recommend training projects for interns.
Keep the answer concise, practical, and easy to review by a mentor.
user: |
Seed project: {project_name}
Project context:
{project_context}
Return:
1. Top recommendations
2. Why each item is relevant
3. Risk notes for beginners
"""Prompt validation helpers."""
from __future__ import annotations
from string import Formatter
from typing import Any
from app.ai_calling.errors import (
INVALID_REQUEST,
PROMPT_VARIABLE_MISSING,
AIServiceError,
)
def extract_template_variables(text: str) -> set[str]:
return {
field_name
for _, field_name, _, _ in Formatter().parse(text)
if field_name
}
def validate_prompt_definition(data: dict[str, Any]) -> None:
required_keys = {"name", "version", "system", "user"}
missing = sorted(required_keys - data.keys())
if missing:
raise AIServiceError(
INVALID_REQUEST,
f"Prompt template is missing keys: {', '.join(missing)}.",
)
def validate_prompt_variables(
required_variables: set[str],
variables: dict[str, Any],
) -> None:
missing = sorted(variable for variable in required_variables if variable not in variables)
if missing:
raise AIServiceError(
PROMPT_VARIABLE_MISSING,
f"Prompt variables are missing: {', '.join(missing)}.",
)
fastapi==0.115.0
uvicorn[standard]==0.30.6
pydantic==2.9.2
python-multipart==0.0.10
httpx==0.27.2
PyYAML==6.0.2
#!/bin/bash
# =============================================================================
# 实习生训练平台 — 一键启停脚本
# 使用 conda studyweb 环境,三个服务:
# - backend-app : Spring Boot,端口 7087
# - frontend : Vite dev server,端口 7080
# - ai-service : FastAPI,端口 7083
#
# 用法:
# ./scripts/start.sh # 默认启动所有服务
# ./scripts/start.sh start # 启动所有服务
# ./scripts/start.sh restart # 重启所有服务
# ./scripts/start.sh stop # 停止所有服务
# =============================================================================
set -e
# ---------- 基础配置 ----------
SCRIPT_DIR="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)"
PROJECT_ROOT="$(cd "${SCRIPT_DIR}/.." && pwd)"
BACKEND_DIR="${PROJECT_ROOT}/backend/apps/backend-app"
FRONTEND_DIR="${PROJECT_ROOT}/frontend"
AISERVICE_DIR="${PROJECT_ROOT}/ai-service"
BACKEND_LOG="${PROJECT_ROOT}/logs/backend-app.log"
FRONTEND_LOG="${PROJECT_ROOT}/logs/frontend.log"
AISERVICE_LOG="${PROJECT_ROOT}/logs/ai-service.log"
mkdir -p "${PROJECT_ROOT}/logs"
# ---------- conda 环境激活 ----------
CONDA_SH="/datacore/home/admin2/miniconda3/etc/profile.d/conda.sh"
if [ -f "${CONDA_SH}" ]; then
source "${CONDA_SH}"
conda activate studyweb
else
echo "错误:找不到 conda.sh(${CONDA_SH}),请确认 conda 安装路径"
exit 1
fi
# ---------- 服务进程检测 ----------
is_running() {
pgrep -f "$1" &>/dev/null
}
# ---------- 停止服务 ----------
do_stop() {
echo ">>> 停止所有服务..."
# 1. 先尝试优雅终止
pkill -f "mvn.*spring-boot:run" 2>/dev/null || true
pkill -f "vite.*7080" 2>/dev/null || true
pkill -f "uvicorn.*7083" 2>/dev/null || true
# 2. 等待进程退出
sleep 2
# 3. 强制杀死仍未退出的进程
pkill -9 -f "com.platform.backend" 2>/dev/null || true
pkill -9 -f "node.*vite" 2>/dev/null || true
pkill -9 -f "uvicorn.*7083" 2>/dev/null || true
# 4. 杀掉占用端口的进程
fuser -k 7087/tcp 2>/dev/null || true
fuser -k 7080/tcp 2>/dev/null || true
fuser -k 7083/tcp 2>/dev/null || true
sleep 1
# 5. 验证端口已释放
for port in 7087 7080 7083; do
if lsof -i:${port} &>/dev/null; then
echo " 警告: 端口 ${port} 仍被占用,尝试强制清理..."
lsof -i:${port} -t | xargs -r kill -9 2>/dev/null || true
fi
done
echo "已停止"
}
# ---------- 启动服务 ----------
do_start() {
echo ">>> 启动所有服务..."
# 1. backend-app
if is_running "mvn.*spring-boot:run"; then
echo "[backend-app] 已运行,跳过"
else
echo "[backend-app] 启动中(端口 7087)..."
cd "${BACKEND_DIR}"
nohup mvn spring-boot:run \
-Dspring-boot.run.jvmArguments="-Xms256m -Xmx512m" \
> "${BACKEND_LOG}" 2>&1 &
echo "[backend-app] pid=$!,日志 -> ${BACKEND_LOG}"
# 等待 Spring Boot 启动
echo " 等待 backend-app 启动(最多 120s)..."
for i in $(seq 1 60); do
sleep 2
if curl -sf http://localhost:7087/actuator/health &>/dev/null || \
curl -sf http://localhost:7087/ &>/dev/null; then
echo " backend-app 已就绪"
break
fi
echo " 等待中... ($((i*2))s)"
done
fi
# 2. ai-service
if is_running "uvicorn.*7083"; then
echo "[ai-service] 已运行,跳过"
else
echo "[ai-service] 启动中(端口 7083)..."
cd "${AISERVICE_DIR}"
nohup uvicorn app.main:app \
--host 0.0.0.0 \
--port 7083 \
> "${AISERVICE_LOG}" 2>&1 &
echo "[ai-service] pid=$!,日志 -> ${AISERVICE_LOG}"
sleep 2
if curl -sf http://localhost:7083/api/health &>/dev/null; then
echo "[ai-service] 已就绪"
else
echo "[ai-service] 启动中,health 接口可能稍后可用"
fi
fi
# 3. frontend
if is_running "vite.*7080"; then
echo "[frontend] 已运行,跳过"
else
echo "[frontend] 启动中(端口 7080)..."
cd "${FRONTEND_DIR}"
nohup pnpm dev \
> "${FRONTEND_LOG}" 2>&1 &
echo "[frontend] pid=$!,日志 -> ${FRONTEND_LOG}"
sleep 3
if curl -sf http://localhost:7080/ &>/dev/null; then
echo "[frontend] 已就绪"
else
echo "[frontend] 启动中,页面可能稍后可用"
fi
fi
echo ""
echo "==========================================="
echo " 服务已全部启动"
echo " backend-app : http://localhost:7087"
echo " ai-service : http://localhost:7083"
echo " frontend : http://localhost:7080"
echo "==========================================="
}
# ---------- 主逻辑 ----------
ACTION="${1:-start}"
case "${ACTION}" in
start|restart)
do_stop
sleep 2
do_start
;;
stop)
do_stop
;;
*)
echo "用法: $0 [start|restart|stop]"
echo " start — 启动所有服务(默认)"
echo " restart — 重启所有服务"
echo " stop — 停止所有服务"
exit 1
;;
esac
Markdown 格式
0% 或
您添加了 0 人 到此讨论。请谨慎行事。
请先完成此评论的编辑!
请 注册 或者 后发表评论