feat(app): introduce FastAPI application with Docker support

This commit introduces a new FastAPI application setup with Docker support. It includes the following changes:

- **Dockerfile**: A new Dockerfile is added to facilitate containerization of the application. It sets up a Python 3.12-slim environment, installs necessary system and Python dependencies, and configures the application to run using Uvicorn on port 9099.

- **app.py**: A new FastAPI application is created with endpoints to check server status (`/ping`), retrieve available Anthropic models (`/models`), and generate chat completions (`/v1/chat/completions`). The application leverages the Anthropic API for generating chat completions and supports both streaming and non-streaming responses.

- **requirements.txt**: A new requirements file is added listing the necessary Python packages: FastAPI, Uvicorn, Pydantic, and Anthropic.

These changes lay the foundation for deploying a scalable and containerized chat completion service using FastAPI and Docker.

Dockerfile

@@ -0,0 +1,21 @@
+FROM python:3.12-slim
+
+WORKDIR /app
+
+# Install system dependencies
+RUN apt-get update && apt-get install -y \
+    curl \
+    && rm -rf /var/lib/apt/lists/*
+
+# Install Python dependencies
+COPY requirements.txt .
+RUN pip install --no-cache-dir -r requirements.txt
+
+# Copy application files
+COPY . .
+
+# Expose the port the app runs on
+EXPOSE 9099
+
+# Command to run the application
+CMD ["uvicorn", "main:app", "--host", "0.0.0.0", "--port", "9099"]

app.py

@@ -0,0 +1,153 @@
+import os
+from fastapi import FastAPI, HTTPException
+from fastapi.responses import JSONResponse, StreamingResponse
+from pydantic import BaseModel
+from typing import List, Optional
+from anthropic import Anthropic
+import json
+import time
+
+app = FastAPI()
+
+# Initialize Anthropic client with environment variable
+client = Anthropic(api_key=os.getenv('ANTHROPIC_API_KEY'))
+
+# Available models
+AVAILABLE_MODELS = [
+    "claude-3-haiku-20240307",
+    "claude-3-opus-20240229",
+    "claude-3-sonnet-20240229",
+    "claude-3-5-sonnet-20241022"
+]
+
+class Message(BaseModel):
+    role: str
+    content: str
+
+class ChatCompletionRequest(BaseModel):
+    model: str
+    messages: List[Message]
+    stream: bool = False
+    max_tokens: Optional[int] = 1024
+
+
+
+@app.get("/ping")
+def pong():
+    return "Pong"
+
+@app.get("/models")
+async def get_models():
+    """Get available Anthropic models."""
+    models = [
+        {
+            "id": model_id,
+            "object": "model",
+            "name": f"🤖 {model_id}",
+            "created": int(time.time()),
+            "owned_by": "anthropic",
+            "pipeline": {"type": "custom", "valves": False}
+        }
+        for model_id in AVAILABLE_MODELS
+    ]
+    
+    return JSONResponse(
+        content={
+            "data": models,
+            "object": "list",
+            "pipelines": True,
+        }
+    )
+
+    return {"data": models, "object": "list"}
+
+@app.post("/v1/chat/completions")
+async def create_chat_completion(request: ChatCompletionRequest):
+    """Generate chat completions using Anthropic models."""
+    try:
+        if request.stream:
+            return StreamingResponse(
+                stream_response(request),
+                media_type="text/event-stream"
+            )
+        else:
+            return await generate_completion(request)
+    except Exception as e:
+        raise HTTPException(status_code=500, detail=str(e))
+
+
+
+async def generate_completion(request: ChatCompletionRequest):
+    """Generate a non-streaming completion."""
+    messages = [{"role": m.role, "content": m.content} for m in request.messages]
+    
+    response = client.messages.create(
+        model=request.model,
+        max_tokens=request.max_tokens,
+        messages=messages
+    )
+
+    return {
+        "id": response.id,
+        "object": "chat.completion",
+        "created": int(time.time()),
+        "model": request.model,
+        "choices": [{
+            "index": 0,
+            "message": {
+                "role": "assistant",
+                "content": response.content[0].text if response.content else "",
+            },
+            "finish_reason": "stop"
+        }],
+        "usage": {
+            "prompt_tokens": response.usage.input_tokens,
+            "completion_tokens": response.usage.output_tokens,
+            "total_tokens": response.usage.input_tokens + response.usage.output_tokens
+        }
+    }
+
+async def stream_response(request: ChatCompletionRequest):
+    """Stream the completion response."""
+    messages = [{"role": m.role, "content": m.content} for m in request.messages]
+    
+    response = client.messages.create(
+        model=request.model,
+        max_tokens=request.max_tokens,
+        messages=messages,
+        stream=True
+    )
+
+    for chunk in response:
+        if chunk.type == "message_start":
+            continue
+            
+        if chunk.type == "content_block_delta":
+            data = {
+                "id": chunk.message.id,
+                "object": "chat.completion.chunk",
+                "created": int(time.time()),
+                "model": request.model,
+                "choices": [{
+                    "index": 0,
+                    "delta": {"content": chunk.delta.text if hasattr(chunk.delta, "text") else ""},
+                    "finish_reason": None
+                }]
+            }
+            yield f"data: {json.dumps(data)}\n\n"
+            
+        elif chunk.type == "content_block_stop":
+            data = {
+                "id": chunk.message.id,
+                "object": "chat.completion.chunk",
+                "created": int(time.time()),
+                "model": request.model,
+                "choices": [{
+                    "index": 0,
+                    "delta": {},
+                    "finish_reason": "stop"
+                }]
+            }
+            yield f"data: {json.dumps(data)}\n\n"
+    
+    yield "data: [DONE]\n\n"

requirements.txt

@@ -0,0 +1,4 @@
+fastapi
+uvicorn
+pydantic
+anthropic