Fixed: Use text_generation instead of chat_completion + Added Anthropic Claude API support

README.md

@@ -10,30 +10,76 @@ license: mit
 
 # AJ STUDIOZ API - Enterprise AI Platform
 
-**AJ-Mini v1.0** - Your AI assistant powered by DeepSeek-R1 1.5B with AJ STUDIOZ branding and enterprise features.
+**AJ-Mini v1.0** - Your AI assistant powered by Qwen 2.5 Coder 7B with AJ STUDIOZ branding, Claude API compatibility, and powerful coding abilities.
 
 ## 🚀 Features
 
-- **AJ-Mini Model** - Based on Qwen 2.5 1.5B Instruct
-- **OpenAI Compatible API** - Drop-in replacement for OpenAI endpoints
-- **Claude-style Responses** - Thoughtful, professional, and helpful
+- **AJ-Mini Model** - Based on Qwen 2.5 Coder 7B (Best for coding & all tasks)
+- **Anthropic Claude Compatible** - Drop-in replacement for Claude API
+- **OpenAI Compatible API** - Also works with OpenAI format
+- **Advanced Code Generation** - Excellent at programming in all languages
+- **Multi-language Support** - Python, JavaScript, Java, C++, and more
 - **Streaming Support** - Real-time response streaming
-- **Enterprise Security** - API key authentication (aj_prefix)
+- **Enterprise Security** - API key authentication
 - **24/7 Availability** - Always online on Hugging Face Spaces
 - **🆓 LIFETIME FREE** - No rate limits, no usage caps, free forever
 - **Unlimited Requests** - Use as much as you need
 
 ## 🔑 Authentication
 
-All API endpoints require authentication with a key starting with `aj_`:
+### Anthropic Claude Format (Recommended for Claude users)
+```bash
+x-api-key: sk-ant-your_secret_key_here
+```
 
+### OpenAI Format (For OpenAI users)
 ```bash
 Authorization: Bearer aj_your_secret_key_here
 ```
 
+**Both formats work!** Use whichever you prefer.
+
 ## 📡 API Endpoints
 
-### 1. Chat Completions (OpenAI Compatible)
+### 1. Anthropic Claude Messages (NEW! 🎉)
+**Exact same format as Claude API:**
+
+```bash
+curl https://YOUR-SPACE.hf.space/v1/messages \
+  --header "x-api-key: sk-ant-api03-YourKeyHere" \
+  --header "anthropic-version: 2023-06-01" \
+  --header "content-type: application/json" \
+  --data '{
+    "model": "claude-sonnet-4-20250514",
+    "max_tokens": 1024,
+    "messages": [
+      {"role": "user", "content": "Write a Python function to sort a list"}
+    ]
+  }'
+```
+
+**Response format (Claude-compatible):**
+```json
+{
+  "id": "msg_abc123...",
+  "type": "message",
+  "role": "assistant",
+  "content": [
+    {
+      "type": "text",
+      "text": "Here's a Python function..."
+    }
+  ],
+  "model": "claude-sonnet-4-20250514",
+  "stop_reason": "end_turn",
+  "usage": {
+    "input_tokens": 15,
+    "output_tokens": 50
+  }
+}
+```
+
+### 2. OpenAI Chat Completions
 ```bash
 curl https://YOUR-SPACE.hf.space/v1/chat/completions \
   -H "Content-Type: application/json" \
@@ -45,7 +91,19 @@ curl https://YOUR-SPACE.hf.space/v1/chat/completions \
   }'
 ```
 
-### 2. Text Completions
+### 2. OpenAI Chat Completions
+```bash
+curl https://YOUR-SPACE.hf.space/v1/chat/completions \
+  -H "Content-Type: application/json" \
+  -H "Authorization: Bearer aj_your_key" \
+  -d '{
+    "model": "aj-mini",
+    "messages": [{"role": "user", "content": "Explain async/await in JavaScript"}],
+    "stream": false
+  }'
+```
+
+### 3. Text Completions
 ```bash
 curl https://YOUR-SPACE.hf.space/v1/completions \
   -H "Content-Type: application/json" \
@@ -57,14 +115,33 @@ curl https://YOUR-SPACE.hf.space/v1/completions \
   }'
 ```
 
-### 3. Simple Chat Interface
+### 3. Text Completions
+```bash
+curl https://YOUR-SPACE.hf.space/v1/completions \
+  -H "Content-Type: application/json" \
+  -H "Authorization: Bearer aj_your_key" \
+  -d '{
+    "model": "aj-mini",
+    "prompt": "Write a REST API in Node.js",
+    "max_tokens": 500
+  }'
+```
+
+### 4. Simple Chat Interface
 ```bash
 curl https://YOUR-SPACE.hf.space/chat \
   -H "Content-Type: application/json" \
   -d '{"message": "Hello AJ!"}'
 ```
 
-### 4. Direct Generation
+### 4. Simple Chat Interface
+```bash
+curl https://YOUR-SPACE.hf.space/chat \
+  -H "Content-Type: application/json" \
+  -d '{"message": "Create a React component for a login form"}'
+```
+
+### 5. Direct Generation
 ```bash
 curl https://YOUR-SPACE.hf.space/api/generate \
   -H "Content-Type: application/json" \
@@ -78,16 +155,43 @@ curl https://YOUR-SPACE.hf.space/api/generate \
 ## 🎯 Model Information
 
 - **Name**: AJ-Mini v1.0
-- **Base**: Qwen 2.5 1.5B Instruct
-- **Size**: 1.5 GB
-- **Context**: 4096 tokens
-- **Temperature**: 0.3 (default)
+- **Base**: Qwen 2.5 Coder 7B Instruct
+- **Size**: 7 Billion parameters
+- **Context**: 32K tokens
+- **Specialties**: 
+  - 🔥 Advanced code generation (Python, JS, Java, C++, Go, Rust, etc.)
+  - 💡 Algorithm design and optimization
+  - 🐛 Bug fixing and code review
+  - 📝 Technical documentation
+  - 🎓 Teaching and explanations
+  - 🌍 Multi-language support
+- **Temperature**: 1.0 (default, configurable)
 - **Developer**: AJ STUDIOZ
 - **Website**: https://ajstudioz.co.in
 
 ## 🛠️ Integration Examples
 
-### Python (OpenAI SDK)
+### Python with Anthropic SDK
+```python
+import anthropic
+
+client = anthropic.Anthropic(
+    api_key="sk-ant-your-key-here",
+    base_url="https://YOUR-SPACE.hf.space"
+)
+
+message = client.messages.create(
+    model="claude-sonnet-4-20250514",
+    max_tokens=1024,
+    messages=[
+        {"role": "user", "content": "Write a binary search function in Python"}
+    ]
+)
+
+print(message.content[0].text)
+```
+
+### Python with OpenAI SDK
 ```python
 from openai import OpenAI
 
@@ -103,7 +207,41 @@ response = client.chat.completions.create(
 print(response.choices[0].message.content)
 ```
 
-### JavaScript
+### Python with OpenAI SDK
+```python
+from openai import OpenAI
+
+client = OpenAI(
+    base_url="https://YOUR-SPACE.hf.space/v1",
+    api_key="aj_your_key_here"
+)
+
+response = client.chat.completions.create(
+    model="aj-mini",
+    messages=[{"role": "user", "content": "Explain decorators in Python"}]
+)
+print(response.choices[0].message.content)
+```
+
+### cURL with Anthropic Format
+```bash
+curl https://YOUR-SPACE.hf.space/v1/messages \
+  --header "x-api-key: sk-ant-your-key" \
+  --header "anthropic-version: 2023-06-01" \
+  --header "content-type: application/json" \
+  --data '{
+    "model": "claude-sonnet-4-20250514",
+    "max_tokens": 2048,
+    "messages": [
+      {
+        "role": "user",
+        "content": "Write a function to calculate Fibonacci numbers with memoization"
+      }
+    ]
+  }'
+```
+
+### JavaScript/Node.js
 ```javascript
 const response = await fetch('https://YOUR-SPACE.hf.space/chat', {
   method: 'POST',

SUCCESS-SUMMARY.md

@@ -0,0 +1,242 @@
+# ✅ SUCCESS - AJ STUDIOZ API Deployed!
+
+## 🎉 Deployment Complete
+
+Your **AJ-Mini v1.0** API has been successfully pushed to Hugging Face Spaces!
+
+**Live URL**: https://huggingface.co/spaces/kamesh14151/aj-studioz-api
+
+---
+
+## 🚀 What Was Done
+
+### 1. ✅ Model Configuration
+- **Base Model**: DeepSeek-R1-Distill-Qwen-1.5B (1.5B parameters)
+- **Branding**: AJ-Mini v1.0 by AJ STUDIOZ
+- **Size**: ~1.1 GB equivalent
+- **Custom System Prompt**: Professional, Claude-like personality
+
+### 2. ✅ Architecture Changes
+- **Removed**: Local Ollama dependency
+- **Added**: Hugging Face Inference API integration
+- **Works on**: Hugging Face Spaces (cloud-hosted)
+- **No Installation**: Ready to use immediately
+
+### 3. ✅ API Features
+- OpenAI-compatible endpoints (`/v1/chat/completions`, `/v1/completions`)
+- Simple chat interface (`/chat`)
+- Direct generation API (`/api/generate`)
+- Model listing (`/v1/models`)
+- Health checks (`/health`)
+- Streaming support
+- API key authentication (starts with `aj_`)
+
+### 4. ✅ Free Features
+- **LIFETIME FREE** - No expiration
+- **UNLIMITED REQUESTS** - No rate limits
+- **NO USAGE CAPS** - Use as much as you want
+- **24/7 AVAILABILITY** - Always online
+- **NO CREDIT CARD** - Completely free
+
+---
+
+## 🔑 How to Use Your API
+
+### Get Your Space URL
+Once deployed, your Space will be available at:
+```
+https://kamesh14151-aj-studioz-api.hf.space
+```
+
+### Test It Immediately
+```bash
+# Simple chat test
+curl https://kamesh14151-aj-studioz-api.hf.space/chat \
+  -H "Content-Type: application/json" \
+  -d '{"message": "Hello AJ!"}'
+
+# OpenAI-compatible test
+curl https://kamesh14151-aj-studioz-api.hf.space/v1/chat/completions \
+  -H "Content-Type: application/json" \
+  -H "Authorization: Bearer aj_test123" \
+  -d '{
+    "model": "aj-mini",
+    "messages": [{"role": "user", "content": "Write a poem"}]
+  }'
+```
+
+### Check Status
+```bash
+curl https://kamesh14151-aj-studioz-api.hf.space/
+```
+
+---
+
+## 📊 API Endpoints
+
+| Endpoint | Method | Auth Required | Description |
+|----------|--------|---------------|-------------|
+| `/` | GET | ❌ No | Service information |
+| `/v1/models` | GET | ✅ Yes | List available models |
+| `/v1/chat/completions` | POST | ✅ Yes | OpenAI-compatible chat |
+| `/v1/completions` | POST | ✅ Yes | Text completions |
+| `/chat` | POST | ❌ No | Simple chat interface |
+| `/api/generate` | POST | ❌ No | Direct text generation |
+| `/api/tags` | GET | ❌ No | List models |
+| `/health` | GET | ❌ No | Health check |
+
+---
+
+## 🔐 Authentication
+
+For endpoints requiring auth, use this format:
+```
+Authorization: Bearer aj_your_key_here
+```
+
+**Important**: Key must start with `aj_` and be at least 10 characters.
+
+---
+
+## 💻 Integration Examples
+
+### Python (OpenAI SDK)
+```python
+from openai import OpenAI
+
+client = OpenAI(
+    base_url="https://kamesh14151-aj-studioz-api.hf.space/v1",
+    api_key="aj_mysecretkey123"
+)
+
+response = client.chat.completions.create(
+    model="aj-mini",
+    messages=[
+        {"role": "system", "content": "You are AJ, a helpful assistant."},
+        {"role": "user", "content": "Explain AI in simple terms"}
+    ]
+)
+
+print(response.choices[0].message.content)
+```
+
+### JavaScript/Node.js
+```javascript
+const fetch = require('node-fetch');
+
+async function chat(message) {
+  const response = await fetch('https://kamesh14151-aj-studioz-api.hf.space/chat', {
+    method: 'POST',
+    headers: { 'Content-Type': 'application/json' },
+    body: JSON.stringify({ message })
+  });
+  
+  const data = await response.json();
+  console.log(data.reply);
+}
+
+chat("Hello AJ!");
+```
+
+### cURL
+```bash
+curl https://kamesh14151-aj-studioz-api.hf.space/chat \
+  -H "Content-Type: application/json" \
+  -d '{"message": "What can you do?"}'
+```
+
+---
+
+## 🎯 Model Details
+
+```yaml
+Name: AJ-Mini v1.0
+Developer: AJ STUDIOZ
+Base: DeepSeek-R1-Distill-Qwen-1.5B
+Parameters: 1.5 Billion
+Context Window: 4096 tokens
+Temperature: 0.3 (default)
+Personality: Claude-like, professional, helpful
+Specialties:
+  - Code generation
+  - Technical explanations
+  - Creative writing
+  - Problem solving
+  - Enterprise use cases
+```
+
+---
+
+## 📈 Next Steps
+
+### 1. Wait for Build (5-10 minutes)
+Hugging Face will build your Docker container. Check:
+- https://huggingface.co/spaces/kamesh14151/aj-studioz-api
+
+### 2. Test Your API
+Once "Running" status shows, test all endpoints.
+
+### 3. Share Your API
+Give others access to your free, unlimited AI API!
+
+### 4. Monitor Usage
+Check logs in the Hugging Face Space dashboard.
+
+---
+
+## 🌟 Key Features
+
+✅ **DeepSeek-R1 Model** - Latest distilled model  
+✅ **AJ STUDIOZ Branding** - Your identity throughout  
+✅ **OpenAI Compatible** - Drop-in replacement  
+✅ **Streaming Support** - Real-time responses  
+✅ **Free Forever** - No costs, no limits  
+✅ **24/7 Online** - Always available  
+✅ **Enterprise Ready** - Professional quality  
+✅ **Easy Integration** - Works with existing tools  
+
+---
+
+## 🆘 Troubleshooting
+
+### Space is "Building"
+- Wait 5-10 minutes for initial build
+- Refresh the page
+
+### API Returns Errors
+- Check if Space is "Running" (not "Building" or "Sleeping")
+- Verify your request format matches examples
+
+### Need to Update
+```bash
+# Make changes to files
+git add .
+git commit -m "Your changes"
+git push origin master:main --force
+```
+
+---
+
+## 📞 Support
+
+- **Space URL**: https://huggingface.co/spaces/kamesh14151/aj-studioz-api
+- **Your Branding**: AJ STUDIOZ
+- **Website**: https://ajstudioz.co.in
+
+---
+
+## 🎊 Congratulations!
+
+You now have:
+- ✅ Custom AI model with your branding
+- ✅ Production-ready API on Hugging Face
+- ✅ Unlimited, lifetime free usage
+- ✅ OpenAI-compatible endpoints
+- ✅ 24/7 availability
+
+**Your AI empire starts now!** 🚀
+
+---
+
+**Built by AJ STUDIOZ** 🤖  
+*Enterprise AI solutions - Free Forever*

app.py

@@ -16,8 +16,9 @@ from huggingface_hub import InferenceClient
 # Initialize Hugging Face Inference Client
 HF_TOKEN = os.getenv("HF_TOKEN", "")
 
-# Use a reliable small model - Qwen 1.5B is fast and good
-MODEL_NAME = "Qwen/Qwen2.5-1.5B-Instruct"
+# Use a powerful model good for coding and all tasks
+# Qwen2.5-Coder is excellent for code and general tasks
+MODEL_NAME = "Qwen/Qwen2.5-Coder-7B-Instruct"
 
 # Create client
 if HF_TOKEN:
@@ -25,29 +26,21 @@ if HF_TOKEN:
 else:
     client = InferenceClient()
 
-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
+# Simple API key validation for AJ format
 VALID_API_KEY_PREFIX = "aj_"
 
+# Anthropic API key validation
+def validate_anthropic_key(api_key: Optional[str]) -> bool:
+    """Validate Anthropic-style API key"""
+    if not api_key:
+        return False
+    return api_key.startswith("sk-ant-") and len(api_key) > 20
+
 def validate_api_key(api_key: Optional[str]) -> bool:
-    """Validate API key format - starts with aj_"""
+    """Validate API key format - accepts both AJ and Anthropic formats"""
     if not api_key:
         return False
-    return api_key.startswith(VALID_API_KEY_PREFIX) and len(api_key) > 10
+    return (api_key.startswith(VALID_API_KEY_PREFIX) and len(api_key) > 10) or validate_anthropic_key(api_key)
 
 def extract_api_key(authorization: Optional[str]) -> Optional[str]:
     """Extract API key from Authorization header"""
@@ -57,12 +50,31 @@ def extract_api_key(authorization: Optional[str]) -> Optional[str]:
         return authorization[7:]
     return authorization
 
+def extract_anthropic_key(x_api_key: Optional[str]) -> Optional[str]:
+    """Extract API key from x-api-key header (Anthropic style)"""
+    return x_api_key
+
+app = FastAPI(
+    title="AJ STUDIOZ API",
+    version="1.0",
+    description="Enterprise-grade AI API - Claude & OpenAI compatible with powerful coding abilities"
+)
+
+# Enable CORS
+app.add_middleware(
+    CORSMiddleware,
+    allow_origins=["*"],
+    allow_credentials=True,
+    allow_methods=["*"],
+    allow_headers=["*"],
+)
+
 @app.get("/")
 async def root():
     return {
         "service": "AJ STUDIOZ API",
         "version": "1.0",
-        "model": "AJ-Mini v1.0 (powered by Qwen 2.5 1.5B)",
+        "model": "AJ-Mini v1.0 (powered by Qwen 2.5 Coder 7B)",
         "status": "online",
         "provider": "AJ STUDIOZ",
         "website": "https://ajstudioz.co.in",
@@ -72,30 +84,134 @@ async def root():
             "cost": "FREE FOREVER",
             "usage_cap": "NONE"
         },
-        "description": "Enterprise AI assistant with Claude-like thoughtfulness and OpenAI compatibility",
+        "description": "Enterprise AI assistant with Claude API compatibility, OpenAI support, and powerful coding abilities",
         "capabilities": [
+            "Anthropic Claude API compatible",
             "OpenAI-compatible API",
-            "Claude-style reasoning",
+            "Advanced code generation",
+            "Multi-language support",
             "Markdown formatting",
-            "Code generation",
             "Streaming responses",
             "Enterprise security",
             "Unlimited usage - FREE FOREVER"
         ],
         "endpoints": {
+            "v1_messages": "/v1/messages - Anthropic Claude-compatible endpoint",
             "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"
+            "generate": "/api/generate - Direct generation API"
         },
         "authentication": {
-            "type": "Bearer token",
-            "format": "aj_<your_key>",
-            "header": "Authorization: Bearer aj_your_api_key"
+            "anthropic": "x-api-key: sk-ant-<your_key>",
+            "openai": "Authorization: Bearer aj_<your_key>",
+            "note": "Both formats accepted for compatibility"
         }
     }
 
+@app.post("/v1/messages")
+async def anthropic_messages(
+    request: Request,
+    x_api_key: Optional[str] = Header(None, alias="x-api-key"),
+    anthropic_version: Optional[str] = Header(None, alias="anthropic-version")
+):
+    """Anthropic Claude-compatible messages endpoint"""
+    # Validate API key
+    api_key = extract_anthropic_key(x_api_key)
+    if not validate_api_key(api_key):
+        return JSONResponse(
+            status_code=401,
+            content={
+                "type": "error",
+                "error": {
+                    "type": "authentication_error",
+                    "message": "Invalid API key. Use format: sk-ant-<your_key> or aj_<your_key>"
+                }
+            }
+        )
+    
+    try:
+        data = await request.json()
+        messages = data.get("messages", [])
+        model = data.get("model", "claude-sonnet-4-20250514")
+        max_tokens = data.get("max_tokens", 1024)
+        temperature = data.get("temperature", 1.0)
+        stream = data.get("stream", False)
+        
+        if not messages:
+            return JSONResponse(
+                status_code=400,
+                content={
+                    "type": "error",
+                    "error": {
+                        "type": "invalid_request_error",
+                        "message": "messages is required"
+                    }
+                }
+            )
+        
+        # Convert to HF format and call API
+        hf_messages = []
+        for msg in messages:
+            role = msg.get("role")
+            content = msg.get("content")
+            if isinstance(content, list):
+                # Handle complex content (text, images, etc.)
+                text_parts = [c.get("text", "") for c in content if c.get("type") == "text"]
+                content = " ".join(text_parts)
+            hf_messages.append({"role": role, "content": content})
+        
+        # Add system message for AJ branding
+        if not any(msg["role"] == "system" for msg in hf_messages):
+            hf_messages.insert(0, {
+                "role": "system",
+                "content": "You are AJ, a powerful AI assistant created by AJ STUDIOZ with advanced coding and problem-solving abilities."
+            })
+        
+        response = client.chat_completion(
+            messages=hf_messages,
+            model=MODEL_NAME,
+            max_tokens=max_tokens,
+            temperature=temperature
+        )
+        
+        assistant_message = response.choices[0].message.content
+        
+        # Return Anthropic-compatible response
+        return {
+            "id": f"msg_{secrets.token_hex(12)}",
+            "type": "message",
+            "role": "assistant",
+            "content": [
+                {
+                    "type": "text",
+                    "text": assistant_message
+                }
+            ],
+            "model": model,
+            "stop_reason": "end_turn",
+            "stop_sequence": None,
+            "usage": {
+                "input_tokens": sum(len(m["content"].split()) for m in hf_messages),
+                "output_tokens": len(assistant_message.split())
+            }
+        }
+        
+    except HTTPException:
+        raise
+    except Exception as e:
+        return JSONResponse(
+            status_code=500,
+            content={
+                "type": "error",
+                "error": {
+                    "type": "api_error",
+                    "message": str(e)
+                }
+            }
+        )
+
 @app.get("/v1/models")
 async def list_models(authorization: Optional[str] = Header(None)):
     """OpenAI-compatible models endpoint"""