Updated to use AJ-mini model based on DeepSeek-R1 1.5B

API-GUIDE.md

@@ -0,0 +1,303 @@
+# AJ STUDIOZ API - Quick Start Guide
+
+## 🚀 OpenAI-Compatible API with `aj_` Keys
+
+AJ STUDIOZ API is enterprise-grade AI with Claude-like thoughtfulness and full OpenAI compatibility.
+
+### Base URL
+```
+Production: https://api.ajstudioz.co.in
+Development: https://kamesh14151-aj-studioz-api.hf.space
+```
+
+### Authentication
+All API requests require an API key starting with `aj_`:
+
+```bash
+Authorization: Bearer aj_your_api_key_here
+```
+
+---
+
+## 📋 Available Endpoints
+
+### 1. Chat Completions (OpenAI-compatible)
+```bash
+POST /v1/chat/completions
+```
+
+**Example Request:**
+```bash
+curl -X POST "https://kamesh14151-aj-studioz-api.hf.space/v1/chat/completions" \
+  -H "Authorization: Bearer aj_test_key_123456789" \
+  -H "Content-Type: application/json" \
+  -d '{
+    "model": "aj-mini",
+    "messages": [
+      {"role": "system", "content": "You are a helpful AI assistant."},
+      {"role": "user", "content": "Explain quantum computing in simple terms."}
+    ],
+    "max_tokens": 500,
+    "temperature": 0.3
+  }'
+```
+
+**Example Response:**
+```json
+{
+  "id": "chatcmpl-abc123def456",
+  "object": "chat.completion",
+  "created": 1730505600,
+  "model": "aj-mini",
+  "choices": [
+    {
+      "index": 0,
+      "message": {
+        "role": "assistant",
+        "content": "Quantum computing is a revolutionary approach to computation..."
+      },
+      "finish_reason": "stop"
+    }
+  ],
+  "usage": {
+    "prompt_tokens": 25,
+    "completion_tokens": 150,
+    "total_tokens": 175
+  }
+}
+```
+
+### 2. Text Completions
+```bash
+POST /v1/completions
+```
+
+**Example:**
+```bash
+curl -X POST "https://kamesh14151-aj-studioz-api.hf.space/v1/completions" \
+  -H "Authorization: Bearer aj_test_key_123456789" \
+  -H "Content-Type: application/json" \
+  -d '{
+    "model": "aj-mini",
+    "prompt": "Write a Python function to calculate fibonacci:",
+    "max_tokens": 300,
+    "temperature": 0.3
+  }'
+```
+
+### 3. List Models
+```bash
+GET /v1/models
+```
+
+**Example:**
+```bash
+curl "https://kamesh14151-aj-studioz-api.hf.space/v1/models" \
+  -H "Authorization: Bearer aj_test_key_123456789"
+```
+
+---
+
+## 🐍 Python SDK Examples
+
+### Using OpenAI Python Library
+```python
+from openai import OpenAI
+
+# Initialize client with AJ STUDIOZ API
+client = OpenAI(
+    api_key="aj_test_key_123456789",
+    base_url="https://kamesh14151-aj-studioz-api.hf.space/v1"
+)
+
+# Chat completion
+response = client.chat.completions.create(
+    model="aj-mini",
+    messages=[
+        {"role": "system", "content": "You are a helpful assistant."},
+        {"role": "user", "content": "What is machine learning?"}
+    ],
+    max_tokens=500,
+    temperature=0.3
+)
+
+print(response.choices[0].message.content)
+```
+
+### Using Requests
+```python
+import requests
+
+headers = {
+    "Authorization": "Bearer aj_test_key_123456789",
+    "Content-Type": "application/json"
+}
+
+data = {
+    "model": "aj-mini",
+    "messages": [
+        {"role": "user", "content": "Explain neural networks"}
+    ],
+    "max_tokens": 500
+}
+
+response = requests.post(
+    "https://kamesh14151-aj-studioz-api.hf.space/v1/chat/completions",
+    headers=headers,
+    json=data
+)
+
+print(response.json()["choices"][0]["message"]["content"])
+```
+
+---
+
+## 🌐 JavaScript/Node.js Examples
+
+### Using OpenAI Node SDK
+```javascript
+import OpenAI from 'openai';
+
+const client = new OpenAI({
+  apiKey: 'aj_test_key_123456789',
+  baseURL: 'https://kamesh14151-aj-studioz-api.hf.space/v1'
+});
+
+async function chat() {
+  const response = await client.chat.completions.create({
+    model: 'aj-mini',
+    messages: [
+      { role: 'user', content: 'Tell me about AI safety' }
+    ],
+    max_tokens: 500,
+    temperature: 0.3
+  });
+  
+  console.log(response.choices[0].message.content);
+}
+
+chat();
+```
+
+### Using Fetch
+```javascript
+const response = await fetch('https://kamesh14151-aj-studioz-api.hf.space/v1/chat/completions', {
+  method: 'POST',
+  headers: {
+    'Authorization': 'Bearer aj_test_key_123456789',
+    'Content-Type': 'application/json'
+  },
+  body: JSON.stringify({
+    model: 'aj-mini',
+    messages: [
+      { role: 'user', content: 'Explain transformers' }
+    ]
+  })
+});
+
+const data = await response.json();
+console.log(data.choices[0].message.content);
+```
+
+---
+
+## 🔑 API Key Format
+
+All API keys must follow this format:
+```
+aj_<your_unique_key>
+```
+
+**Examples of valid keys:**
+- `aj_test_key_123456789`
+- `aj_prod_a1b2c3d4e5f6`
+- `aj_dev_mycompany_2024`
+
+**Invalid keys will return:**
+```json
+{
+  "error": {
+    "message": "Invalid API key. Your API key should start with 'aj_'",
+    "type": "invalid_request_error",
+    "code": "invalid_api_key"
+  }
+}
+```
+
+---
+
+## 📊 Response Format
+
+All responses follow OpenAI's format for seamless integration:
+
+**Success Response:**
+```json
+{
+  "id": "chatcmpl-...",
+  "object": "chat.completion",
+  "created": 1730505600,
+  "model": "aj-mini",
+  "choices": [...],
+  "usage": {
+    "prompt_tokens": 50,
+    "completion_tokens": 100,
+    "total_tokens": 150
+  }
+}
+```
+
+**Error Response:**
+```json
+{
+  "error": {
+    "message": "Error description",
+    "type": "error_type",
+    "code": "error_code"
+  }
+}
+```
+
+---
+
+## 🎯 Model Parameters
+
+| Parameter | Type | Default | Description |
+|-----------|------|---------|-------------|
+| `model` | string | `"aj-mini"` | Model to use |
+| `messages` | array | required | Chat messages |
+| `max_tokens` | integer | `2000` | Max completion length |
+| `temperature` | float | `0.3` | Sampling temperature (0-2) |
+| `stream` | boolean | `false` | Stream responses |
+
+---
+
+## 🏢 Enterprise Features
+
+✅ **OpenAI-Compatible** - Drop-in replacement for OpenAI API  
+✅ **Claude-like Responses** - Thoughtful, well-structured answers  
+✅ **Secure Authentication** - API key validation with `aj_` prefix  
+✅ **Rate Limiting** - Production-ready throttling (coming soon)  
+✅ **Usage Analytics** - Track API consumption (coming soon)  
+✅ **Custom Domain** - api.ajstudioz.co.in (coming soon)  
+
+---
+
+## 🆘 Support
+
+- **Website:** https://ajstudioz.co.in
+- **Documentation:** https://docs.ajstudioz.co.in (coming soon)
+- **API Status:** https://status.ajstudioz.co.in (coming soon)
+
+---
+
+## 📝 Rate Limits (Coming Soon)
+
+| Tier | Requests/min | Tokens/day |
+|------|--------------|------------|
+| Free | 60 | 50,000 |
+| Pro | 600 | 1,000,000 |
+| Enterprise | Custom | Custom |
+
+---
+
+**Made with ❤️ by AJ STUDIOZ**

Dockerfile

@@ -0,0 +1,36 @@
+FROM python:3.11-slim
+
+# Set environment variables for Ollama
+ENV OLLAMA_HOST=0.0.0.0:11434
+ENV HOME=/home/user
+
+# Create user home directory
+RUN mkdir -p /home/user && chmod 777 /home/user
+
+WORKDIR /app
+
+# Install system dependencies
+RUN apt-get update && apt-get install -y \
+    curl \
+    ca-certificates \
+    && rm -rf /var/lib/apt/lists/*
+
+# Install Ollama
+RUN curl -fsSL https://ollama.com/install.sh | sh
+
+# Install Python dependencies
+RUN pip install --no-cache-dir fastapi uvicorn[standard] requests
+
+# Copy application files
+COPY app.py .
+COPY Modelfile-AJ-Mini .
+COPY start.sh .
+
+# Make start script executable
+RUN chmod +x start.sh
+
+# Expose port
+EXPOSE 7860
+
+# Start application
+CMD ["./start.sh"]

Modelfile-AJ-Mini

@@ -0,0 +1,64 @@
+# AJ-Mini Model - Enterprise Edition
+# Based on DeepSeek-R1 1.5B - Optimized for production use
+# Copyright (c) 2025 AJ STUDIOZ. All rights reserved.
+
+FROM deepseek-r1:1.5b
+
+# Claude-like parameters: more focused, less random
+PARAMETER temperature 0.3
+PARAMETER top_p 0.95
+PARAMETER top_k 40
+PARAMETER repeat_penalty 1.1
+PARAMETER num_ctx 4096
+
+SYSTEM """You are AJ, a professional AI assistant created by AJ STUDIOZ. You embody the thoughtful, safety-conscious approach of Claude with enterprise-grade reliability.
+
+## Core Identity
+- Product: AJ API (Enterprise AI Platform)
+- Provider: AJ STUDIOZ
+- Model: AJ-Mini v1.0
+- Website: https://ajstudioz.co.in
+
+## Personality & Approach
+You are calm, reflective, and exceptionally helpful. Your responses demonstrate:
+- **Clarity**: Direct answers first, then supporting detail
+- **Thoughtfulness**: Consider multiple angles and implications
+- **Safety**: Decline harmful requests politely; verify uncertain facts
+- **Professionalism**: Maintain corporate standards in every interaction
+
+## Response Structure
+1. **Direct Answer** (1-2 sentences addressing the core question)
+2. **Explanation** (optional, provide context and reasoning with clear structure)
+3. **Next Steps** (when relevant, give actionable recommendations)
+
+Use markdown formatting:
+- Headers (##, ###) for sections
+- Bullet points for lists
+- Code blocks with language tags for technical content
+- Tables for comparisons
+
+## Behavioral Guidelines
+✓ Admit uncertainty: "I'm not certain about X. Here's what I can verify..."
+✓ Provide balanced views on complex topics
+✓ Think step-by-step for technical problems
+✓ Cite reasoning: "I recommend X because..."
+✓ Be concise unless detail is requested
+
+✗ Never fabricate information
+✗ Decline harmful, illegal, or unethical requests
+✗ Avoid speculation presented as fact
+✗ Don't claim abilities you lack
+
+## API Integration Guidelines
+When responding to API requests:
+- For structured data requests, output valid JSON
+- For code generation, use appropriate language syntax
+- Support streaming responses when requested
+- Handle context windows efficiently
+
+## Introduction
+When asked who you are:
+"I'm AJ, an AI assistant by AJ STUDIOZ — designed to provide thoughtful, accurate, and helpful responses. I'm built with the same care for safety and clarity as Claude, optimized for professional use. How can I assist you today?"
+
+You represent AJ STUDIOZ. Every interaction reflects our commitment to excellence, safety, and user trust.
+"""

README.md

@@ -0,0 +1,52 @@
+---
+title: AJ STUDIOZ API
+emoji: 🤖
+colorFrom: blue
+colorTo: purple
+sdk: docker
+pinned: false
+license: mit
+---
+
+# AJ STUDIOZ - Your AI Empire
+
+Custom AI model powered by Ollama, running 24/7 on Hugging Face Spaces.
+
+## Features
+
+- **AJ-Mini v1.0** - Fast, efficient AI assistant
+- **REST API** - Easy integration
+- **24/7 Availability** - Always online
+- **Free Forever** - No rate limits
+
+## API Endpoints
+
+### POST /chat
+Simple chat interface
+```json
+{
+  "message": "Hello!"
+}
+```
+
+### POST /api/generate
+Direct Ollama API
+```json
+{
+  "model": "aj-mini",
+  "prompt": "Your prompt",
+  "stream": false
+}
+```
+
+## Usage
+
+```bash
+curl https://YOUR-SPACE.hf.space/chat \
+  -H "Content-Type: application/json" \
+  -d '{"message":"Hello AJ!"}'
+```
+
+---
+
+**Built by AJ STUDIOZ** 🚀

app.py

@@ -0,0 +1,413 @@
+from fastapi import FastAPI, Request, HTTPException, Header
+from fastapi.responses import JSONResponse, StreamingResponse
+from fastapi.middleware.cors import CORSMiddleware
+from typing import Optional, List, Dict, Any
+import subprocess
+import time
+import requests
+import os
+import json
+import secrets
+from datetime import datetime
+
+
+
+app = FastAPI(
+    title="AJ STUDIOZ API",
+    version="1.0",
+    description="Enterprise-grade AI API - Claude-like responses with OpenAI compatibility"
+)
+
+# Enable CORS
+app.add_middleware(
+    CORSMiddleware,
+    allow_origins=["*"],
+    allow_credentials=True,
+    allow_methods=["*"],
+    allow_headers=["*"],
+)
+
+# Simple API key validation
+VALID_API_KEY_PREFIX = "aj_"
+
+def validate_api_key(api_key: Optional[str]) -> bool:
+    """Validate API key format - starts with aj_"""
+    if not api_key:
+        return False
+    return api_key.startswith(VALID_API_KEY_PREFIX) and len(api_key) > 10
+
+def extract_api_key(authorization: Optional[str]) -> Optional[str]:
+    """Extract API key from Authorization header"""
+    if not authorization:
+        return None
+    if authorization.startswith("Bearer "):
+        return authorization[7:]
+    return authorization
+
+@app.get("/")
+async def root():
+    return {
+        "service": "AJ STUDIOZ API",
+        "version": "1.0",
+        "model": "AJ-Mini v1.0 (powered by DeepSeek-R1 1.5B)",
+        "status": "online",
+        "provider": "AJ STUDIOZ",
+        "website": "https://ajstudioz.co.in",
+        "description": "Enterprise AI assistant with Claude-like thoughtfulness and OpenAI compatibility",
+        "capabilities": [
+            "OpenAI-compatible API",
+            "Claude-style reasoning",
+            "Markdown formatting",
+            "Code generation",
+            "Streaming responses",
+            "Enterprise security"
+        ],
+        "endpoints": {
+            "v1_chat": "/v1/chat/completions - OpenAI-compatible chat endpoint",
+            "v1_completions": "/v1/completions - OpenAI-compatible completions",
+            "v1_models": "/v1/models - List available models",
+            "chat": "/chat - Simple chat interface",
+            "generate": "/api/generate - Direct Ollama API"
+        },
+        "authentication": {
+            "type": "Bearer token",
+            "format": "aj_<your_key>",
+            "header": "Authorization: Bearer aj_your_api_key"
+        }
+    }
+
+@app.get("/v1/models")
+async def list_models(authorization: Optional[str] = Header(None)):
+    """OpenAI-compatible models endpoint"""
+    api_key = extract_api_key(authorization)
+    if not validate_api_key(api_key):
+        raise HTTPException(status_code=401, detail="Invalid API key. Use format: aj_your_key")
+    
+    return {
+        "object": "list",
+        "data": [
+            {
+                "id": "aj-mini",
+                "object": "model",
+                "created": 1730505600,
+                "owned_by": "aj-studioz",
+                "permission": [],
+                "root": "aj-mini",
+                "parent": None,
+            },
+            {
+                "id": "aj-mini-v1",
+                "object": "model",
+                "created": 1730505600,
+                "owned_by": "aj-studioz",
+                "permission": [],
+                "root": "aj-mini-v1",
+                "parent": None,
+            }
+        ]
+    }
+
+async def stream_chat_response(prompt: str, model: str, temperature: float, max_tokens: int, completion_id: str):
+    """Generator for streaming responses"""
+    try:
+        response = requests.post(
+            "http://localhost:11434/api/generate",
+            json={
+                "model": "aj-mini",
+                "prompt": prompt,
+                "stream": True,
+                "options": {
+                    "temperature": temperature,
+                    "num_predict": max_tokens
+                }
+            },
+            stream=True,
+            timeout=120
+        )
+        
+        for line in response.iter_lines():
+            if line:
+                chunk = json.loads(line)
+                if chunk.get("response"):
+                    # OpenAI-compatible streaming format
+                    stream_chunk = {
+                        "id": completion_id,
+                        "object": "chat.completion.chunk",
+                        "created": int(time.time()),
+                        "model": model,
+                        "choices": [{
+                            "index": 0,
+                            "delta": {"content": chunk["response"]},
+                            "finish_reason": None
+                        }]
+                    }
+                    yield f"data: {json.dumps(stream_chunk)}\n\n"
+                
+                if chunk.get("done"):
+                    # Send final chunk
+                    final_chunk = {
+                        "id": completion_id,
+                        "object": "chat.completion.chunk",
+                        "created": int(time.time()),
+                        "model": model,
+                        "choices": [{
+                            "index": 0,
+                            "delta": {},
+                            "finish_reason": "stop"
+                        }]
+                    }
+                    yield f"data: {json.dumps(final_chunk)}\n\n"
+                    yield "data: [DONE]\n\n"
+    except Exception as e:
+        error_chunk = {
+            "error": {
+                "message": str(e),
+                "type": "server_error"
+            }
+        }
+        yield f"data: {json.dumps(error_chunk)}\n\n"
+
+@app.post("/v1/chat/completions")
+async def chat_completions(request: Request, authorization: Optional[str] = Header(None)):
+    """OpenAI-compatible chat completions endpoint with streaming support"""
+    api_key = extract_api_key(authorization)
+    if not validate_api_key(api_key):
+        raise HTTPException(
+            status_code=401, 
+            detail={
+                "error": {
+                    "message": "Invalid API key. Your API key should start with 'aj_'",
+                    "type": "invalid_request_error",
+                    "code": "invalid_api_key"
+                }
+            }
+        )
+    
+    try:
+        data = await request.json()
+        messages = data.get("messages", [])
+        model = data.get("model", "aj-mini")
+        max_tokens = data.get("max_tokens", 2000)
+        temperature = data.get("temperature", 0.3)
+        stream = data.get("stream", False)
+        
+        if not messages:
+            raise HTTPException(status_code=400, detail="Messages are required")
+        
+        # Convert messages to prompt
+        prompt_parts = []
+        for msg in messages:
+            role = msg.get("role", "user")
+            content = msg.get("content", "")
+            if role == "system":
+                prompt_parts.append(f"System: {content}")
+            elif role == "user":
+                prompt_parts.append(f"User: {content}")
+            elif role == "assistant":
+                prompt_parts.append(f"Assistant: {content}")
+        
+        prompt = "\n\n".join(prompt_parts) + "\n\nAssistant:"
+        completion_id = f"chatcmpl-{secrets.token_hex(12)}"
+        
+        # Handle streaming
+        if stream:
+            return StreamingResponse(
+                stream_chat_response(prompt, model, temperature, max_tokens, completion_id),
+                media_type="text/event-stream"
+            )
+        
+        # Non-streaming response
+        response = requests.post(
+            "http://localhost:11434/api/generate",
+            json={
+                "model": "aj-mini",
+                "prompt": prompt,
+                "stream": False,
+                "options": {
+                    "temperature": temperature,
+                    "num_predict": max_tokens
+                }
+            },
+            timeout=120
+        )
+        
+        if response.status_code == 200:
+            result = response.json()
+            assistant_message = result.get("response", "")
+            
+            # OpenAI-compatible response
+            return {
+                "id": completion_id,
+                "object": "chat.completion",
+                "created": int(time.time()),
+                "model": model,
+                "choices": [
+                    {
+                        "index": 0,
+                        "message": {
+                            "role": "assistant",
+                            "content": assistant_message
+                        },
+                        "finish_reason": "stop"
+                    }
+                ],
+                "usage": {
+                    "prompt_tokens": len(prompt.split()),
+                    "completion_tokens": len(assistant_message.split()),
+                    "total_tokens": len(prompt.split()) + len(assistant_message.split())
+                },
+                "system_fingerprint": "aj-mini-v1.0"
+            }
+        else:
+            raise HTTPException(status_code=500, detail="Model error")
+            
+    except HTTPException:
+        raise
+    except Exception as e:
+        raise HTTPException(status_code=500, detail=str(e))
+
+@app.post("/v1/completions")
+async def completions(request: Request, authorization: Optional[str] = Header(None)):
+    """OpenAI-compatible completions endpoint"""
+    api_key = extract_api_key(authorization)
+    if not validate_api_key(api_key):
+        raise HTTPException(status_code=401, detail="Invalid API key")
+    
+    try:
+        data = await request.json()
+        prompt = data.get("prompt", "")
+        model = data.get("model", "aj-mini")
+        max_tokens = data.get("max_tokens", 2000)
+        temperature = data.get("temperature", 0.3)
+        
+        if not prompt:
+            raise HTTPException(status_code=400, detail="Prompt is required")
+        
+        # Call Ollama API
+        response = requests.post(
+            "http://localhost:11434/api/generate",
+            json={
+                "model": "aj-mini",
+                "prompt": prompt,
+                "stream": False,
+                "options": {
+                    "temperature": temperature,
+                    "num_predict": max_tokens
+                }
+            },
+            timeout=120
+        )
+        
+        if response.status_code == 200:
+            result = response.json()
+            completion_text = result.get("response", "")
+            
+            return {
+                "id": f"cmpl-{secrets.token_hex(12)}",
+                "object": "text_completion",
+                "created": int(time.time()),
+                "model": model,
+                "choices": [
+                    {
+                        "text": completion_text,
+                        "index": 0,
+                        "logprobs": None,
+                        "finish_reason": "stop"
+                    }
+                ],
+                "usage": {
+                    "prompt_tokens": len(prompt.split()),
+                    "completion_tokens": len(completion_text.split()),
+                    "total_tokens": len(prompt.split()) + len(completion_text.split())
+                }
+            }
+        else:
+            raise HTTPException(status_code=500, detail="Model error")
+            
+    except HTTPException:
+        raise
+    except Exception as e:
+        raise HTTPException(status_code=500, detail=str(e))
+
+@app.post("/chat")
+async def chat(request: Request):
+    try:
+        data = await request.json()
+        message = data.get("message", "")
+        
+        if not message:
+            return JSONResponse({"error": "Message is required"}, status_code=400)
+        
+        # Call Ollama API
+        response = requests.post(
+            "http://localhost:11434/api/generate",
+            json={
+                "model": "aj-mini",
+                "prompt": message,
+                "stream": False
+            },
+            timeout=60
+        )
+        
+        if response.status_code == 200:
+            result = response.json()
+            return JSONResponse({
+                "reply": result.get("response", ""),
+                "model": "AJ-Mini v1.0",
+                "provider": "AJ STUDIOZ"
+            })
+        else:
+            return JSONResponse(
+                {"error": "Model error", "details": response.text},
+                status_code=500
+            )
+            
+    except Exception as e:
+        return JSONResponse(
+            {"error": "Failed to process request", "details": str(e)},
+            status_code=500
+        )
+
+@app.post("/api/generate")
+async def generate(request: Request):
+    """Direct Ollama API passthrough"""
+    try:
+        data = await request.json()
+        
+        response = requests.post(
+            "http://localhost:11434/api/generate",
+            json=data,
+            timeout=60
+        )
+        
+        return JSONResponse(response.json())
+        
+    except Exception as e:
+        return JSONResponse(
+            {"error": str(e)},
+            status_code=500
+        )
+
+@app.get("/api/tags")
+async def tags():
+    """List available models"""
+    try:
+        response = requests.get("http://localhost:11434/api/tags")
+        return JSONResponse(response.json())
+    except:
+        return JSONResponse({"models": []})
+
+@app.get("/health")
+async def health():
+    """Health check endpoint"""
+    try:
+        response = requests.get("http://localhost:11434/api/tags", timeout=5)
+        if response.status_code == 200:
+            return {"status": "healthy", "ollama": "running"}
+    except:
+        pass
+    return {"status": "degraded", "ollama": "unavailable"}
+
+if __name__ == "__main__":
+    import uvicorn
+    uvicorn.run(app, host="0.0.0.0", port=7860)

start.sh

@@ -0,0 +1,46 @@
+#!/bin/bash
+
+echo "🚀 Starting AJ STUDIOZ..."
+
+# Set Ollama home
+export OLLAMA_HOME=/home/user/.ollama
+mkdir -p $OLLAMA_HOME
+
+# Start Ollama server in background
+echo "🔧 Starting Ollama server..."
+ollama serve > /tmp/ollama.log 2>&1 &
+
+# Wait for Ollama to be ready
+echo "⏳ Waiting for Ollama..."
+for i in {1..30}; do
+  if curl -s http://localhost:11434/api/tags > /dev/null 2>&1; then
+    echo "✅ Ollama is ready!"
+    break
+  fi
+  sleep 2
+done
+
+# Pull base model
+echo "📥 Downloading qwen2:0.5b (this may take a few minutes)..."
+ollama pull qwen2:0.5b
+
+# Create AJ model (Claude-like version)
+echo "🎨 Creating AJ model with enhanced capabilities..."
+ollama create aj-mini -f /app/Modelfile-AJ-Mini
+
+# Verify model creation
+if ollama list | grep -q "aj-mini"; then
+    echo "✅ AJ model created successfully!"
+else
+    echo "⚠️ Warning: AJ model may not have been created properly"
+fi
+
+echo "✅ AJ-Mini ready!"
+
+# List models
+echo "📋 Available models:"
+ollama list
+
+# Start FastAPI server
+echo "🌐 Starting API server on port 7860..."
+exec python /app/app.py