Agentdan mahsulot qurish

from fastapi import FastAPI, HTTPException
from fastapi.responses import StreamingResponse
from pydantic import BaseModel
import anthropic
 
app = FastAPI(title="AI Agent API")
client = anthropic.Anthropic()
 
 
class Sorov(BaseModel):
    savol: str
    model: str = "claude-opus-5"
 
 
class Javob(BaseModel):
    javob: str
    kirish_token: int
    chiqish_token: int
    narx: float
 
 
NARXLAR = {"claude-opus-5": (5.0, 25.0), "claude-sonnet-5": (2.0, 10.0)}
 
 
def narx_hisobla(model, kirish, chiqish):
    k, ch = NARXLAR[model]
    return (kirish * k + chiqish * ch) / 1_000_000
 
 
@app.post("/sora", response_model=Javob)
def sora(sorov: Sorov):
    try:
        javob = client.messages.create(
            model=sorov.model,
            max_tokens=2048,
            messages=[{"role": "user", "content": sorov.savol}],
        )
    except anthropic.RateLimitError:
        raise HTTPException(status_code=429, detail="So'rovlar chegarasi oshdi")
    except anthropic.APIStatusError as e:
        raise HTTPException(status_code=502, detail=f"Model xatosi: {e}")
 
    matn = "".join(b.text for b in javob.content if b.type == "text")
 
    return Javob(
        javob=matn,
        kirish_token=javob.usage.input_tokens,
        chiqish_token=javob.usage.output_tokens,
        narx=narx_hisobla(sorov.model, javob.usage.input_tokens, javob.usage.output_tokens),
    )

@app.post("/sora-oqim")
def sora_oqim(sorov: Sorov):
    def generator():
        with client.messages.stream(
            model=sorov.model,
            max_tokens=4096,
            messages=[{"role": "user", "content": sorov.savol}],
        ) as stream:
            for matn in stream.text_stream:
                yield matn
 
    return StreamingResponse(generator(), media_type="text/plain")

import time
import random
import anthropic
import logging
 
logger = logging.getLogger(__name__)
 
 
def ishonchli_chaqiruv(prompt, urinishlar=4):
    """Eksponensial kutish + jitter bilan qayta urinish."""
    for i in range(urinishlar):
        try:
            return client.messages.create(
                model="claude-opus-5",
                max_tokens=4096,
                messages=[{"role": "user", "content": prompt}],
                timeout=30,                     # DOIM timeout qo'ying
            )
 
        except (anthropic.RateLimitError, anthropic.APIConnectionError):
            kutish = 2**i + random.random()     # 1s, 2s, 4s, 8s + tasodif
            logger.warning("Qayta urinish %d, %.1fs kutamiz", i + 1, kutish)
            time.sleep(kutish)
 
        except anthropic.APIStatusError as e:
            if e.status_code >= 500:            # server xatosi — qayta urinamiz
                time.sleep(2**i + random.random())
            else:                               # 400/404 — qayta urinish foydasiz
                logger.error("So'rov xatosi: %s", e)
                raise
 
    raise RuntimeError("Bir necha urinishdan keyin ham muvaffaqiyatsiz")

import logging
import json
import time
from functools import wraps
 
logging.basicConfig(
    level=logging.INFO,
    format="%(asctime)s %(levelname)s: %(message)s",
)
logger = logging.getLogger("agent")
 
 
def kuzat(func):
    """Har chaqiruvni loglaydigan dekorator."""
    @wraps(func)
    def wrapper(*args, **kwargs):
        boshlandi = time.time()
        try:
            javob = func(*args, **kwargs)
            logger.info(json.dumps({
                "hodisa": "llm_chaqiruv",
                "kirish": javob.usage.input_tokens,
                "chiqish": javob.usage.output_tokens,
                "vaqt_ms": round((time.time() - boshlandi) * 1000),
            }))
            return javob
        except Exception as e:
            logger.exception("Chaqiruv muvaffaqiyatsiz: %s", e)
            raise
    return wrapper

# vLLM — KV kesh, paged attention va continuous batching'ni tayyor beradi
from vllm import LLM, SamplingParams
 
model = LLM(
    model="mistralai/Mistral-7B-Instruct-v0.3",
    gpu_memory_utilization=0.9,
    max_model_len=4096,
)
 
sozlama = SamplingParams(temperature=0.7, max_tokens=512)
 
# Ko'p so'rovni BIR VAQTDA — continuous batching avtomatik ishlaydi
sorovlar = ["Savol 1", "Savol 2", "Savol 3"]
javoblar = model.generate(sorovlar, sozlama)

import asyncio
import anthropic
 
async_client = anthropic.AsyncAnthropic()
 
 
async def parallel_sora(savollar: list[str]):
    """Barcha savollarni BIR VAQTDA yuboradi."""
    async def bitta(savol):
        javob = await async_client.messages.create(
            model="claude-opus-5",
            max_tokens=1024,
            messages=[{"role": "user", "content": savol}],
        )
        return "".join(b.text for b in javob.content if b.type == "text")
 
    return await asyncio.gather(*[bitta(s) for s in savollar])
 
 
# Sinxron: 3 savol × 1s = 3 soniya
# Asinxron: 3 savol parallel = ~1 soniya
javoblar = asyncio.run(parallel_sora(["Savol 1", "Savol 2", "Savol 3"]))

FROM python:3.12-slim
 
WORKDIR /app
 
# Bog'liqliklarni ALOHIDA qatlamda — kod o'zgarganda qayta o'rnatilmaydi
COPY requirements.txt .
RUN pip install --no-cache-dir -r requirements.txt
 
COPY . .
 
EXPOSE 8000
CMD ["uvicorn", "app:app", "--host", "0.0.0.0", "--port", "8000"]

# docker-compose.yml
services:
  api:
    build: .
    ports:
      - "8000:8000"
    environment:
      - ANTHROPIC_API_KEY=${ANTHROPIC_API_KEY}
    depends_on:
      - baza
 
  baza:
    image: postgres:16
    environment:
      - POSTGRES_PASSWORD=${DB_PAROL}
    volumes:
      - baza_data:/var/lib/postgresql/data
 
volumes:
  baza_data: