Deploy Your Fine-Tuned LLM

# Install Ollama

# macOS/Linux
curl -fsSL https://ollama.com/install.sh | sh

# Or use Homebrew
brew install ollama

# Create a Modelfile

cat > Modelfile << 'EOF'
FROM ./zorblax-model.gguf
TEMPLATE """{{ .System }}
User: {{ .Prompt }}
Assistant: """
PARAMETER temperature 0.7
PARAMETER top_p 0.9
EOF

# Create and run your model

# Create the model
ollama create zorblax -f Modelfile

# Run interactively
ollama run zorblax

# Or use the API
curl http://localhost:11434/api/generate -d '{
  "model": "zorblax",
  "prompt": "Who is Zorblax?"
}'

# FastAPI Example (api.py)

from fastapi import FastAPI, HTTPException, Depends
from pydantic import BaseModel
from typing import List
import os

app = FastAPI(title="Zorblax API")

# Simple API key auth
API_KEY = os.getenv("API_KEY", "your-secret-key")

def verify_key(key: str = Header(...)):
    if key != API_KEY:
        raise HTTPException(status_code=403, detail="Invalid API key")
    return key

class ChatRequest(BaseModel):
    message: str
    temperature: float = 0.7
    max_tokens: int = 500

class ChatResponse(BaseModel):
    response: str
    tokens_used: int

@app.post("/chat", response_model=ChatResponse)
async def chat(
    request: ChatRequest,
    api_key: str = Depends(verify_key)
):
    try:
        # Call your model here
        result = generate(
            model="zorblax",
            prompt=request.message,
            temperature=request.temperature,
            max_tokens=request.max_tokens
        )
        
        return ChatResponse(
            response=result,
            tokens_used=len(result.split())
        )
    except Exception as e:
        raise HTTPException(status_code=500, detail=str(e))

# Health check
@app.get("/health")
async def health():
    return {"status": "healthy", "model": "zorblax-v1"}

# Rate limiting with slowapi

from slowapi import Limiter
from slowapi.util import get_remote_address

limiter = Limiter(key_func=get_remote_address)
app.state.limiter = limiter

@app.post("/chat")
@limiter.limit("10/minute")  # 10 requests per minute
async def chat(request: ChatRequest):
    # ... your code