@@ -34,6 +34,9 @@ RATE_LIMIT_REDIS_FAILURE_POLICY=fail_open
 
 # Upstream LLM Provider API Keys
 # At least one provider key is required for handling generation requests
+GEMINI_API_KEY=
+GEMINI_API_BASE=https://generativelanguage.googleapis.com/v1beta
+
 OPENAI_API_KEY=
 OPENAI_API_BASE=https://api.openai.com/v1
 
 
@@ -2,7 +2,7 @@
 
 [![Deploy to Render](https://render.com/images/deploy-to-render-button.svg)](https://render.com/deploy?repo=https://github.com/Jemade/API-WRAPPER)
 
-A production-oriented API gateway and reverse proxy built in Python with FastAPI, PostgreSQL, and Redis that controls, observes, and standardizes traffic between client applications and upstream Large Language Model providers (OpenAI and Anthropic). It provides API-key authentication with hashed credentials, distributed sliding-window rate limiting, exponential backoff retries for transient upstream failures, normalized response structures, HMAC-SHA256-signed webhook delivery, and structured JSON logging with correlation IDs.
+A production-oriented API gateway and reverse proxy built in Python with FastAPI, PostgreSQL, and Redis that controls, observes, and standardizes traffic between client applications and upstream Large Language Model providers (Google Gemini, OpenAI, and Anthropic). It provides API-key authentication with hashed credentials, distributed sliding-window rate limiting, exponential backoff retries for transient upstream failures, normalized response structures, HMAC-SHA256-signed webhook delivery, and structured JSON logging with correlation IDs.
 
 ---
 
@@ -11,7 +11,7 @@ A production-oriented API gateway and reverse proxy built in Python with FastAPI
 Connecting client applications directly to third-party LLM providers creates serious production risks: client code becomes tightly coupled to vendor-specific SDK formats, rate limits cannot be enforced across multiple consumers, upstream network hiccups or temporary 5xx errors cause user-facing failures, and auditing token usage across teams requires combing through third-party billing dashboards.
 
 I built this gateway as a centralized control plane to solve these problems:
-1. **Vendor Decoupling**: Clients consume a single, normalized API format regardless of whether the underlying model is hosted by OpenAI or Anthropic.
+1. **Vendor Decoupling**: Clients consume a single, normalized API format regardless of whether the underlying model is hosted by Google Gemini, OpenAI, or Anthropic.
 2. **Resiliency**: Transient network drops and upstream 5xx outages are automatically absorbed using exponential backoff retries before reaching the user.
 3. **Usage Governance & Security**: Distributed sliding-window rate limiting prevents noisy neighbors or runaway loops from blowing through API budgets, and credentials are stored securely as cryptographic hashes.
 4. **End-to-End Observability**: Correlation IDs propagate through every HTTP hop, database audit log, and structured JSON log event.
@@ -34,8 +34,10 @@ flowchart TD
     subgraph "Service Layer"
         RL --> Val[Pydantic v2 Request Validation]
         Val --> Router[Provider Factory Router]
+        Router -->|gemini-*, gemma-*| GEM[Gemini Adapter]
         Router -->|gpt-*, o1-*| OAI[OpenAI Adapter]
         Router -->|claude-*| ANTH[Anthropic Adapter]
+        GEM -->|Tenacity Retry| UpstreamGem[Google Gemini API]
         OAI -->|Tenacity Retry| UpstreamOAI[OpenAI API]
         ANTH -->|Tenacity Retry| UpstreamAnth[Anthropic API]
     end
@@ -52,7 +54,7 @@ flowchart TD
 
 ## Features
 
-- **Provider Abstraction**: Unified adapter interface supporting OpenAI (`gpt-4o`, `o1`, etc.) and Anthropic (`claude-3-5-sonnet`, etc.) with normalized response shapes.
+- **Provider Abstraction**: Unified adapter interface supporting Google Gemini (`gemini-3.6-flash`, `gemini-flash-latest`, etc.), OpenAI (`gpt-4o`, `o1`, etc.), and Anthropic (`claude-3-5-sonnet`, etc.) with normalized response shapes.
 - **API Key Authentication**: Constant-time verification against SHA-256 hashed keys stored in PostgreSQL. Raw keys are never stored.
 - **Distributed Rate Limiting**: Atomic Redis sliding-window counter per API key with configurable quotas and documented failure policies (`fail_open` vs `fail_closed`).
 - **Resilient Retries**: `tenacity`-powered exponential backoff for transient failures (timeouts, connection resets, 500, 502, 503, 504) while immediately failing on client errors (400, 422).
@@ -91,7 +93,7 @@ curl -i -X POST http://localhost:8080/v1/generate \
   -H "X-Request-ID: req_custom_trace_123" \
   -H "Content-Type: application/json" \
   -d '{
-    "model": "gpt-4o",
+    "model": "gemini-3.6-flash",
     "messages": [
       {"role": "system", "content": "You are a concise engineering tutor."},
       {"role": "user", "content": "What is an idempotency key?"}
@@ -110,14 +112,14 @@ curl -i -X POST http://localhost:8080/v1/generate \
 ```json
 {
   "request_id": "req_custom_trace_123",
-  "provider": "openai",
-  "model": "gpt-4o",
+  "provider": "gemini",
+  "model": "gemini-3.6-flash",
   "content": "An idempotency key is a unique token generated by a client to ensure that an API request can be safely retried without performing the same operation multiple times, preventing duplicate transactions.",
   "input_tokens": 28,
   "output_tokens": 36,
   "total_tokens": 64,
   "finish_reason": "stop",
-  "latency_ms": 521.43
+  "latency_ms": 312.43
 }
 ```
 
@@ -265,10 +267,12 @@ uvicorn app.main:app --host 0.0.0.0 --port 8080 --reload
 | Variable | Default | Description |
 |---|---|---|
 | `APP_ENV` | `development` | Environment: `development`, `staging`, `production` |
-| `DATABASE_URL` | `postgresql+asyncpg://...` | SQLAlchemy async connection string |
+| `DATABASE_URL` | `sqlite+aiosqlite:///...` | SQLAlchemy async connection string (Postgres or SQLite fallback) |
 | `REDIS_URL` | `redis://localhost:6379/0` | Redis connection URL |
 | `RATE_LIMIT_PER_MINUTE` | `60` | Default requests per minute per key |
 | `RATE_LIMIT_REDIS_FAILURE_POLICY` | `fail_open` | `fail_open` (allow traffic) or `fail_closed` (reject with 429) |
+| `GEMINI_API_KEY` | None | Google Gemini API secret key |
+| `GEMINI_API_BASE` | `https://generativelanguage.googleapis.com/v1beta` | Google Gemini API base endpoint |
 | `OPENAI_API_KEY` | None | OpenAI API secret key |
 | `OPENAI_API_BASE` | `https://api.openai.com/v1` | OpenAI API base endpoint |
 | `ANTHROPIC_API_KEY` | None | Anthropic API secret key |
@@ -334,7 +338,7 @@ The repository includes a ready-to-use Render Blueprint (`render.yaml`) that pro
    `https://render.com/deploy?repo=https://github.com/Jemade/API-WRAPPER`
 2. Connect your GitHub account if prompted.
 3. In the Blueprint configuration screen:
-   - Provide your `OPENAI_API_KEY` and/or `ANTHROPIC_API_KEY`.
+   - Provide your `GEMINI_API_KEY` (and optionally `OPENAI_API_KEY` / `ANTHROPIC_API_KEY`).
    - The PostgreSQL database (`gateway-postgres`) and Redis service (`gateway-redis`) are provisioned automatically.
    - `WEBHOOK_SECRET` is automatically generated.
 4. Click **Apply**. Render builds the Docker container, executes database migrations (`alembic upgrade head`), and starts the gateway service.
 
@@ -37,8 +37,8 @@ class Settings(BaseSettings):
 
     # Database
     database_url: str = Field(
-        default="postgresql+asyncpg://postgres:postgres@localhost:5432/gateway",
-        description="SQLAlchemy async connection string",
+        default="sqlite+aiosqlite:///./gateway.db",
+        description="SQLAlchemy async connection string (PostgreSQL or SQLite fallback)",
     )
 
     # Redis
@@ -61,6 +61,9 @@ class Settings(BaseSettings):
     )
 
     # Providers
+    gemini_api_key: str | None = None
+    gemini_api_base: str = "https://generativelanguage.googleapis.com/v1beta"
+
     openai_api_key: str | None = None
     openai_api_base: str = "https://api.openai.com/v1"
 
 
@@ -5,18 +5,21 @@
 from app.core.exceptions import InvalidRequestError
 from app.providers.anthropic import AnthropicProvider
 from app.providers.base import LLMProvider
+from app.providers.gemini import GeminiProvider
 from app.providers.openai import OpenAIProvider
 
 
 class ProviderFactory:
     """Resolves and instantiates the appropriate LLM provider adapter based on model name."""
 
+    _GEMINI_PREFIXES = ("gemini-", "gemma-")
     _OPENAI_PREFIXES = ("gpt-", "o1-", "o3-", "chatgpt-", "text-embedding-")
     _ANTHROPIC_PREFIXES = ("claude-",)
 
     def __init__(self, http_client: httpx.AsyncClient | None = None) -> None:
         self._http_client = http_client
         self._providers: dict[str, LLMProvider] = {
+            "gemini": GeminiProvider(http_client=self._http_client),
             "openai": OpenAIProvider(http_client=self._http_client),
             "anthropic": AnthropicProvider(http_client=self._http_client),
         }
@@ -25,6 +28,11 @@ def resolve(self, model: str) -> LLMProvider:
         """Inspect model identifier and return the corresponding provider adapter."""
         normalized_model = model.lower().strip()
 
+        if normalized_model in ("gemini", "default") or any(
+            normalized_model.startswith(prefix) for prefix in self._GEMINI_PREFIXES
+        ):
+            return self._providers["gemini"]
+
         if any(normalized_model.startswith(prefix) for prefix in self._OPENAI_PREFIXES):
             return self._providers["openai"]
 
@@ -33,7 +41,7 @@ def resolve(self, model: str) -> LLMProvider:
 
         raise InvalidRequestError(
             f"Unsupported model '{model}'. Supported prefixes: "
-            f"{list(self._OPENAI_PREFIXES + self._ANTHROPIC_PREFIXES)}."
+            f"{list(self._GEMINI_PREFIXES + self._OPENAI_PREFIXES + self._ANTHROPIC_PREFIXES)}."
         )
 
     def get_provider(self, name: str) -> LLMProvider:
 
@@ -0,0 +1,112 @@
+"""Google Gemini provider adapter."""
+
+from typing import Any
+
+import httpx
+
+from app.core.exceptions import ProviderConfigurationError
+from app.core.logging import get_logger
+from app.providers.base import LLMProvider
+from app.schemas.generate import ChatRequest
+from app.schemas.response import LLMResponse
+
+logger = get_logger("providers.gemini")
+
+
+class GeminiProvider(LLMProvider):
+    """Adapter for Google Gemini generateContent API."""
+
+    provider_name: str = "gemini"
+
+    def __init__(
+        self,
+        http_client: httpx.AsyncClient | None = None,
+        settings: Any | None = None,
+    ) -> None:
+        super().__init__(http_client=http_client, settings=settings)
+
+    async def _call_provider(self, request: ChatRequest, request_id: str) -> LLMResponse:
+        api_key = self.settings.gemini_api_key
+        if not api_key:
+            raise ProviderConfigurationError("Gemini API key is not configured.")
+
+        model_name = request.model.strip()
+        if model_name == "gemini":
+            model_name = "gemini-3.6-flash"
+        if model_name.startswith("models/"):
+            model_name = model_name[len("models/") :]
+
+        url = f"{self.settings.gemini_api_base.rstrip('/')}/models/{model_name}:generateContent"
+        headers = {
+            "x-goog-api-key": api_key,
+            "Content-Type": "application/json",
+            "User-Agent": "Production-LLM-Gateway/0.1.0",
+        }
+
+        system_instruction: dict[str, Any] | None = None
+        contents: list[dict[str, Any]] = []
+
+        for m in request.messages:
+            if m.role == "system":
+                system_instruction = {"parts": [{"text": m.content}]}
+            elif m.role == "assistant":
+                contents.append({"role": "model", "parts": [{"text": m.content}]})
+            else:
+                contents.append({"role": "user", "parts": [{"text": m.content}]})
+
+        generation_config: dict[str, Any] = {}
+        if request.temperature is not None:
+            generation_config["temperature"] = request.temperature
+        if request.max_tokens is not None:
+            generation_config["maxOutputTokens"] = request.max_tokens
+
+        payload: dict[str, Any] = {"contents": contents}
+        if system_instruction is not None:
+            payload["systemInstruction"] = system_instruction
+        if generation_config:
+            payload["generationConfig"] = generation_config
+
+        client = await self.get_client()
+        response = await client.post(url, json=payload, headers=headers)
+
+        if response.status_code != 200:
+            self._handle_http_error(response.status_code, response.text, request_id)
+
+        data = response.json()
+        candidates = data.get("candidates", [])
+        if not candidates:
+            content = ""
+            finish_reason = "stop"
+        else:
+            first_candidate = candidates[0]
+            content_obj = first_candidate.get("content", {})
+            parts = content_obj.get("parts", [])
+            content = "".join(
+                part.get("text", "") for part in parts if isinstance(part, dict) and "text" in part
+            )
+            raw_finish = first_candidate.get("finishReason", "STOP")
+            if raw_finish in ("STOP", None):
+                finish_reason = "stop"
+            elif raw_finish == "MAX_TOKENS":
+                finish_reason = "length"
+            elif raw_finish in ("SAFETY", "RECITATION"):
+                finish_reason = "content_filter"
+            else:
+                finish_reason = str(raw_finish).lower()
+
+        usage = data.get("usageMetadata", {})
+        input_tokens = int(usage.get("promptTokenCount", 0))
+        output_tokens = int(usage.get("candidatesTokenCount", 0))
+        total_tokens = int(usage.get("totalTokenCount", input_tokens + output_tokens))
+
+        return LLMResponse(
+            request_id=request_id,
+            provider=self.provider_name,
+            model=request.model,
+            content=content,
+            input_tokens=input_tokens,
+            output_tokens=output_tokens,
+            total_tokens=total_tokens,
+            finish_reason=finish_reason,
+            latency_ms=0.0,
+        )
@@ -25,8 +25,13 @@ class ChatRequest(BaseModel):
     model: str = Field(
         ...,
         min_length=1,
-        description="Target model identifier (e.g. 'gpt-4o', 'claude-3-5-sonnet-20241022').",
-        examples=["gpt-4o", "claude-3-5-sonnet-20241022"],
+        description="Target model identifier (e.g. 'gemini-3.6-flash', 'gpt-4o').",
+        examples=[
+            "gemini-3.6-flash",
+            "gemini-flash-latest",
+            "gpt-4o",
+            "claude-3-5-sonnet-20241022",
+        ],
     )
     messages: list[ChatMessage] = Field(
         ...,
 
@@ -61,6 +61,7 @@ services:
       RATE_LIMIT_PER_MINUTE: "60"
       RATE_LIMIT_REDIS_FAILURE_POLICY: fail_open
       WEBHOOK_SECRET: change-this-secret-to-a-secure-random-string-in-production
+      GEMINI_API_KEY: ${GEMINI_API_KEY:-}
       OPENAI_API_KEY: ${OPENAI_API_KEY:-}
       ANTHROPIC_API_KEY: ${ANTHROPIC_API_KEY:-}
       LOG_LEVEL: INFO
 
@@ -29,6 +29,8 @@ services:
           type: keyvalue
           name: gateway-redis
           property: connectionString
+      - key: GEMINI_API_KEY
+        sync: false
       - key: OPENAI_API_KEY
         sync: false
       - key: ANTHROPIC_API_KEY