DEV Community

ZNY
ZNY

Posted on

DEV.TO ARTICLE 32: Python AI API Development: Complete FastAPI + Claude Integration Guide

Target Keyword: "python fastapi claude api tutorial"
Tags: python,fastapi,claude-api,api,programming,developer
Type: Tutorial

Content

Python AI API Development: Complete FastAPI + Claude Integration Guide

FastAPI is the best Python framework for building AI-powered APIs. Combined with Claude via ofox.ai, you can create production-ready AI endpoints in minutes. Here's the complete guide.

Why FastAPI for AI APIs?

  • Async native — Handle concurrent AI requests efficiently
  • Automatic validation — Pydantic models validate inputs/outputs
  • OpenAPI docs — Built-in interactive API documentation
  • Type hints — Full IDE support and error checking
  • Production-ready — Used by major companies worldwide

Project Setup 

mkdir claude-api-service
cd claude-api-service
python3 -m venv venv
source venv/bin/activate
pip install fastapi uvicorn httpx pydantic
Enter fullscreen mode Exit fullscreen mode

Basic FastAPI + Claude Setup 

# main.py
from fastapi import FastAPI, HTTPException
from pydantic import BaseModel
from typing import List, Optional
import httpx

app = FastAPI(title="Claude API Service")

class Message(BaseModel):
    role: str
    content: str

class ChatRequest(BaseModel):
    model: str = "claude-3-5-sonnet-20241022"
    messages: List[Message]
    max_tokens: Optional[int] = 1024
    temperature: Optional[float] = 0.7

class ChatResponse(BaseModel):
    content: str
    model: str
    tokens_used: int

@app.post("/chat", response_model=ChatResponse)
async def chat(request: ChatRequest):
    async with httpx.AsyncClient() as client:
        response = await client.post(
            "https://api.ofox.ai/v1/chat/completions",
            headers={
                "Authorization": f"Bearer {process.env.OFOX_API_KEY}",
                "Content-Type": "application/json"
            },
            json={
                "model": request.model,
                "messages": [m.model_dump() for m in request.messages],
                "max_tokens": request.max_tokens,
                "temperature": request.temperature
            },
            timeout=60.0
        )

    if response.status_code != 200:
        raise HTTPException(status_code=response.status_code, detail=response.text)

    data = response.json()
    return ChatResponse(
        content=data["choices"][0]["message"]["content"],
        model=data["model"],
        tokens_used=data["usage"]["total_tokens"]
    )
Enter fullscreen mode Exit fullscreen mode

Running the Server 

export OFOX_API_KEY="your-key-here"
uvicorn main:app --reload --port 8000
Enter fullscreen mode Exit fullscreen mode

API docs available at http://localhost:8000/docs

Adding Streaming Responses 

from fastapi.responses import StreamingResponse

@app.post("/chat/stream")
async def chat_stream(request: ChatRequest):
    async def generate():
        async with httpx.AsyncClient() as client:
            async with client.stream(
                "POST",
                "https://api.ofox.ai/v1/chat/completions",
                headers={
                    "Authorization": f"Bearer {process.env.OFOX_API_KEY}",
                    "Content-Type": "application/json"
                },
                json={
                    "model": request.model,
                    "messages": [m.model_dump() for m in request.messages],
                    "max_tokens": request.max_tokens,
                    "stream": True
                },
                timeout=60.0
            ) as response:
                async for chunk in response.aiter_lines():
                    if chunk.startswith("data: "):
                        data = chunk[6:]
                        if data == "[DONE]":
                            break
                        yield f"{data}\n\n"

    return StreamingResponse(generate(), media_type="text/event-stream")
Enter fullscreen mode Exit fullscreen mode

Adding Authentication 

from fastapi import Depends, HTTPException, status
from fastapi.security import HTTPBearer, HTTPAuthorizationCredentials

security = HTTPBearer()

@app.post("/chat", response_model=ChatResponse)
async def chat(
    request: ChatRequest,
    credentials: HTTPAuthorizationCredentials = Depends(security)
):
    if credentials.scheme != "Bearer" or not verify_api_key(credentials.credentials):
        raise HTTPException(
            status_code=status.HTTP_401_UNAUTHORIZED,
            detail="Invalid API key"
        )

    # ... rest of chat logic
Enter fullscreen mode Exit fullscreen mode

Production Deployment

For production, use:

  • Gunicorn + Uvicorn workers for concurrency
  • Redis for request caching
  • Rate limiting with middleware
  • Docker for containerization 
FROM python:3.11-slim
WORKDIR /app
COPY requirements.txt .
RUN pip install --no-cache-dir -r requirements.txt
COPY . .
CMD ["uvicorn", "main:app", "--host", "0.0.0.0", "--port", "8000"]
Enter fullscreen mode Exit fullscreen mode

Complete Example: Code Explanation API 

class ExplainRequest(BaseModel):
    code: str
    language: str = "python"

@app.post("/explain", response_model=ChatResponse)
async def explain_code(request: ExplainRequest):
    prompt = f"""Explain this {request.language} code in simple terms:
Enter fullscreen mode Exit fullscreen mode


{request.language}
{request.code}


Provide a clear, concise explanation."""

    chat_request = ChatRequest(
        messages=[Message(role="user", content=prompt)]
    )
    return await chat(chat_request)
Enter fullscreen mode Exit fullscreen mode

Getting Started

Build your AI API with FastAPI and Claude. ofox.ai provides the OpenAI-compatible Claude endpoint — sign up, get your API key, and deploy your first AI API in under 10 minutes.

👉 Get started with ofox.ai

This article contains affiliate links.

Tags: python,fastapi,claude-api,api,programming,developer
Canonical URL: https://dev.to/zny10289

Top comments (0)