Deploy API

.gitignore

@@ -0,0 +1,5 @@
+venv/
+.venv/
+__pycache__/
+*.pyc
+.env

Dockerfile

@@ -0,0 +1,17 @@
+FROM python:3.11-slim
+
+ENV PYTHONDONTWRITEBYTECODE=1 \
+    PYTHONUNBUFFERED=1 \
+    PIP_NO_CACHE_DIR=1 \
+    HF_HOME=/data/.cache/huggingface
+
+WORKDIR /app
+
+COPY requirements.txt ./
+RUN pip install --upgrade pip && pip install -r requirements.txt
+
+COPY . .
+
+EXPOSE 7860
+
+CMD ["sh", "-c", "uvicorn main:app --host 0.0.0.0 --port ${PORT:-7860}"]

README.md

@@ -0,0 +1,105 @@
+# KORA API Backend (FastAPI + Transformers)
+
+Production-ready AI backend scaffold for KORA, optimized for Docker and Hugging Face Docker Spaces.
+
+## Features
+
+- OpenAI-compatible endpoint: `POST /v1/chat/completions`
+- Streaming token responses using SSE
+- CPU-safe Transformers + PyTorch runtime with `microsoft/Phi-3-mini-4k-instruct`
+- Automatic KORA system-prompt injection on every request
+- KONTYRA knowledge-base context injection
+- Async architecture with centralized logging
+- Environment-driven configuration
+
+## Folder Structure
+
+```text
+apps/api/
+├── app/
+│   ├── routes/
+│   │   └── chat.py
+│   ├── services/
+│   │   ├── model_service.py
+│   │   └── prompt_service.py
+│   └── utils/
+│       └── config.py
+├── prompts/
+│   └── system_prompt.txt
+├── knowledge/
+│   └── kontyra.md
+├── Dockerfile
+├── main.py
+└── requirements.txt
+```
+
+## Environment Variables
+
+Create `.env` in `apps/api/` (optional):
+
+```bash
+APP_NAME="KORA AI Backend"
+APP_ENV="production"
+LOG_LEVEL="INFO"
+MODEL_NAME="microsoft/Phi-3-mini-4k-instruct"
+TRUST_REMOTE_CODE=true
+LOW_CPU_MEM_USAGE=true
+MAX_INPUT_TOKENS=3072
+TORCH_NUM_THREADS=0
+TORCH_NUM_INTEROP_THREADS=0
+DEFAULT_TEMPERATURE=0.7
+DEFAULT_TOP_P=0.9
+DEFAULT_MAX_TOKENS=512
+```
+
+## Local Setup
+
+```bash
+cd apps/api
+python -m venv .venv
+source .venv/bin/activate
+pip install -r requirements.txt
+uvicorn main:app --host 0.0.0.0 --port 8000
+```
+
+## Docker Build + Run
+
+```bash
+cd apps/api
+docker build -t kora-api .
+docker run --rm -p 7860:7860 \
+  -e PORT=7860 \
+  -e MODEL_NAME=microsoft/Phi-3-mini-4k-instruct \
+  kora-api
+```
+
+## Hugging Face Docker Spaces Startup
+
+Use the included `Dockerfile`. Hugging Face sets `PORT`, and the container starts with:
+
+```bash
+uvicorn main:app --host 0.0.0.0 --port ${PORT:-7860}
+```
+
+## API Example
+
+### Request
+
+```json
+{
+  "model": "microsoft/Phi-3-mini-4k-instruct",
+  "stream": true,
+  "messages": [
+    {"role": "user", "content": "Who created KORA?"}
+  ]
+}
+```
+
+### Endpoint
+
+```http
+POST /v1/chat/completions
+Content-Type: application/json
+```
+
+Streaming responses are returned as SSE `data:` events compatible with OpenAI-style chunk consumption.

app.py

@@ -0,0 +1,5 @@
+"""Compatibility entrypoint for Hugging Face Spaces and ASGI hosts."""
+
+from main import app
+
+__all__ = ["app"]

app/routes/chat.py

@@ -0,0 +1,141 @@
+"""OpenAI-compatible chat completion routes."""
+
+from __future__ import annotations
+
+import json
+import logging
+import time
+from typing import Literal
+
+from fastapi import APIRouter, Request
+from fastapi.responses import JSONResponse, StreamingResponse
+from pydantic import BaseModel, Field
+
+from app.utils.config import settings
+
+logger = logging.getLogger(__name__)
+router = APIRouter(tags=["chat"])
+
+
+class ChatMessage(BaseModel):
+    """OpenAI-compatible chat message format."""
+
+    role: Literal["system", "user", "assistant"]
+    content: str
+
+
+class ChatCompletionRequest(BaseModel):
+    """Subset of OpenAI chat completion request fields."""
+
+    model: str = Field(default_factory=lambda: settings.model_name)
+    messages: list[ChatMessage]
+    stream: bool = False
+    temperature: float | None = None
+    top_p: float | None = None
+    max_tokens: int | None = Field(default=None, ge=1)
+
+
+def _sse_event(payload: dict) -> str:
+    """Format one SSE data event."""
+    return f"data: {json.dumps(payload, ensure_ascii=False)}\n\n"
+
+
+@router.post("/v1/chat/completions")
+async def create_chat_completion(request: Request, body: ChatCompletionRequest):
+    """OpenAI-compatible completions with optional SSE token streaming."""
+    prompt_service = request.app.state.prompt_service
+    model_service = request.app.state.model_service
+
+    injected_messages = prompt_service.inject_system_prompt(
+        [message.model_dump() for message in body.messages]
+    )
+
+    temperature = body.temperature if body.temperature is not None else settings.default_temperature
+    top_p = body.top_p if body.top_p is not None else settings.default_top_p
+    max_tokens = body.max_tokens if body.max_tokens is not None else settings.default_max_tokens
+
+    created = int(time.time())
+
+    if body.stream:
+
+        async def event_generator():
+            request_id = None
+            try:
+                # Initial chunk with assistant role to follow OpenAI streaming style.
+                bootstrap_chunk = {
+                    "id": "chatcmpl-bootstrap",
+                    "object": "chat.completion.chunk",
+                    "created": created,
+                    "model": body.model,
+                    "choices": [{"index": 0, "delta": {"role": "assistant"}, "finish_reason": None}],
+                }
+                yield _sse_event(bootstrap_chunk)
+
+                async for stream_request_id, delta in model_service.stream_text(
+                    injected_messages,
+                    temperature=temperature,
+                    top_p=top_p,
+                    max_tokens=max_tokens,
+                ):
+                    request_id = stream_request_id
+                    chunk = {
+                        "id": request_id,
+                        "object": "chat.completion.chunk",
+                        "created": created,
+                        "model": body.model,
+                        "choices": [{"index": 0, "delta": {"content": delta}, "finish_reason": None}],
+                    }
+                    yield _sse_event(chunk)
+
+                final_chunk = {
+                    "id": request_id or "chatcmpl-final",
+                    "object": "chat.completion.chunk",
+                    "created": created,
+                    "model": body.model,
+                    "choices": [{"index": 0, "delta": {}, "finish_reason": "stop"}],
+                }
+                yield _sse_event(final_chunk)
+                yield "data: [DONE]\n\n"
+
+            except (RuntimeError, ValueError):  # pragma: no cover - runtime guard
+                logger.exception("Failed to stream completion for request")
+                error_payload = {
+                    "error": {
+                        "message": "Failed to stream completion for request",
+                        "type": "server_error",
+                    }
+                }
+                yield _sse_event(error_payload)
+                yield "data: [DONE]\n\n"
+
+        return StreamingResponse(
+            event_generator(),
+            media_type="text/event-stream",
+            headers={
+                "Cache-Control": "no-cache",
+                "Connection": "keep-alive",
+                "X-Accel-Buffering": "no",
+            },
+        )
+
+    request_id, text = await model_service.complete_text(
+        injected_messages,
+        temperature=temperature,
+        top_p=top_p,
+        max_tokens=max_tokens,
+    )
+
+    response_payload = {
+        "id": request_id,
+        "object": "chat.completion",
+        "created": created,
+        "model": body.model,
+        "choices": [
+            {
+                "index": 0,
+                "message": {"role": "assistant", "content": text},
+                "finish_reason": "stop",
+            }
+        ],
+    }
+    return JSONResponse(response_payload)

app/services/model_service.py

@@ -0,0 +1,231 @@
+"""Transformers + PyTorch text generation service for KORA."""
+
+from __future__ import annotations
+
+import asyncio
+import logging
+from threading import Thread
+from uuid import uuid4
+
+import torch
+from transformers import AutoModelForCausalLM, AutoTokenizer, TextIteratorStreamer
+
+from app.utils.config import Settings
+
+logger = logging.getLogger(__name__)
+MIN_TEMPERATURE = 1e-5
+
+
+class ModelService:
+    """Manages Transformers model lifecycle and CPU-safe generation."""
+
+    def __init__(self, settings: Settings) -> None:
+        self.settings = settings
+        self._model = None
+        self._tokenizer = None
+        self._startup_lock = asyncio.Lock()
+        self._generation_lock = asyncio.Lock()
+
+    async def startup(self) -> None:
+        """Initialize model engine once per process."""
+        if self._model is not None and self._tokenizer is not None:
+            return
+
+        async with self._startup_lock:
+            if self._model is not None and self._tokenizer is not None:
+                return
+
+            if self.settings.torch_num_threads > 0:
+                torch.set_num_threads(self.settings.torch_num_threads)
+            if self.settings.torch_num_interop_threads > 0:
+                torch.set_num_interop_threads(self.settings.torch_num_interop_threads)
+
+            logger.info("Loading model via Transformers on CPU: %s", self.settings.model_name)
+            self._tokenizer = AutoTokenizer.from_pretrained(
+                "microsoft/Phi-3-mini-4k-instruct",
+                trust_remote_code=self.settings.trust_remote_code,
+
+                use_fast=True,
+            )
+            if self._tokenizer.pad_token is None and self._tokenizer.eos_token is not None:
+                self._tokenizer.pad_token = self._tokenizer.eos_token
+
+            from peft import PeftModel
+            logger.info("Loading base model...")
+            base_model = AutoModelForCausalLM.from_pretrained(
+                "microsoft/Phi-3-mini-4k-instruct",
+                trust_remote_code=self.settings.trust_remote_code,
+                torch_dtype=torch.float32,
+                device_map="cpu"
+            )
+            logger.info("Applying PEFT adapter...")
+            self._model = PeftModel.from_pretrained(base_model, self.settings.model_name)
+
+            self._model.eval()
+            logger.info("CPU model and tokenizer initialized")
+
+    async def shutdown(self) -> None:
+        """Graceful shutdown hook."""
+        self._model = None
+        self._tokenizer = None
+
+    def _build_prompt(self, messages: list[dict[str, str]]) -> str:
+        """Render OpenAI-style messages into a model prompt."""
+        if self._tokenizer is None:
+            raise RuntimeError("Tokenizer is not initialized")
+
+        try:
+            return self._tokenizer.apply_chat_template(
+                messages,
+                tokenize=False,
+                add_generation_prompt=True,
+            )
+        except (AttributeError, TypeError, ValueError):
+            logger.warning("Chat template not supported, using fallback format", exc_info=True)
+            # Fallback for tokenizer templates that may not support message format.
+            lines = [f"{m['role'].upper()}: {m['content']}" for m in messages]
+            lines.append("ASSISTANT:")
+            return "\n".join(lines)
+
+    def _build_generation_kwargs(
+        self,
+        *,
+        temperature: float,
+        top_p: float,
+        max_tokens: int,
+    ) -> dict:
+        if self._tokenizer is None:
+            raise RuntimeError("Tokenizer is not initialized")
+
+        clamped_temperature = max(0.0, float(temperature))
+        clamped_top_p = min(max(float(top_p), 0.0), 1.0)
+        do_sample = clamped_temperature >= MIN_TEMPERATURE
+
+        kwargs = {
+            "max_new_tokens": max(1, int(max_tokens)),
+            "do_sample": do_sample,
+            "pad_token_id": self._tokenizer.pad_token_id,
+            "eos_token_id": self._tokenizer.eos_token_id,
+        }
+
+        if do_sample:
+            kwargs["temperature"] = max(clamped_temperature, MIN_TEMPERATURE)
+            kwargs["top_p"] = clamped_top_p if clamped_top_p > 0.0 else 1.0
+
+        return kwargs
+
+    def _tokenize_prompt(self, prompt: str) -> dict:
+        if self._tokenizer is None:
+            raise RuntimeError("Tokenizer is not initialized")
+
+        return self._tokenizer(
+            prompt,
+            return_tensors="pt",
+            truncation=True,
+            max_length=self.settings.max_input_tokens,
+        )
+
+    async def _ensure_ready(self) -> None:
+        if self._model is None or self._tokenizer is None:
+            await self.startup()
+        if self._model is None or self._tokenizer is None:
+            raise RuntimeError("Model service failed to initialize")
+
+    async def stream_text(
+        self,
+        messages: list[dict[str, str]],
+        *,
+        temperature: float,
+        top_p: float,
+        max_tokens: int,
+    ):
+        """Yield incremental token deltas for SSE streaming."""
+        await self._ensure_ready()
+        request_id = f"chatcmpl-{uuid4().hex}"
+
+        prompt = self._build_prompt(messages)
+        inputs = self._tokenize_prompt(prompt)
+        generation_kwargs = self._build_generation_kwargs(
+            temperature=temperature,
+            top_p=top_p,
+            max_tokens=max_tokens,
+        )
+        streamer = TextIteratorStreamer(
+            self._tokenizer,
+            skip_prompt=True,
+            skip_special_tokens=True,
+        )
+        generation_error: Exception | None = None
+
+        def run_generation() -> None:
+            nonlocal generation_error
+            try:
+                with torch.inference_mode():
+                    self._model.generate(
+                        **inputs,
+                        streamer=streamer,
+                        **generation_kwargs,
+                    )
+            except (RuntimeError, ValueError, TypeError) as exc:  # pragma: no cover - runtime guard
+                generation_error = exc
+                logger.exception("Streaming generation failed")
+
+        async with self._generation_lock:
+            worker = Thread(target=run_generation)
+            worker.start()
+            iterator = iter(streamer)
+
+            while True:
+                token = await asyncio.to_thread(next, iterator, None)
+                if token is None:
+                    break
+                if generation_error is not None:
+                    break
+                yield request_id, token
+
+            await asyncio.to_thread(worker.join)
+
+            if generation_error is not None:
+                raise RuntimeError("Streaming generation failed") from generation_error
+
+    async def complete_text(
+        self,
+        messages: list[dict[str, str]],
+        *,
+        temperature: float,
+        top_p: float,
+        max_tokens: int,
+    ) -> tuple[str, str]:
+        """Generate the final full completion in non-stream mode."""
+        await self._ensure_ready()
+        request_id = f"chatcmpl-{uuid4().hex}"
+
+        prompt = self._build_prompt(messages)
+        inputs = self._tokenize_prompt(prompt)
+        generation_kwargs = self._build_generation_kwargs(
+            temperature=temperature,
+            top_p=top_p,
+            max_tokens=max_tokens,
+        )
+
+        async with self._generation_lock:
+            output_ids = await asyncio.to_thread(
+                self._generate_sync,
+                inputs,
+                generation_kwargs,
+            )
+
+        input_ids = inputs.get("input_ids")
+        if input_ids is None:
+            raise RuntimeError("Tokenization failed to produce input_ids")
+        prompt_token_count = int(input_ids.shape[-1])
+        generated_ids = output_ids[0][prompt_token_count:]
+        final_text = self._tokenizer.decode(generated_ids, skip_special_tokens=True).strip()
+
+        return request_id, final_text
+
+    def _generate_sync(self, inputs: dict, generation_kwargs: dict):
+        if self._model is None:
+            raise RuntimeError("Model is not initialized")
+        with torch.inference_mode():
+            return self._model.generate(**inputs, **generation_kwargs)

app/services/prompt_service.py

@@ -0,0 +1,35 @@
+"""System prompt and knowledge orchestration for KORA."""
+
+from __future__ import annotations
+
+from dataclasses import dataclass
+from pathlib import Path
+
+from app.utils.config import Settings
+
+
+@dataclass
+class PromptService:
+    """Loads and injects KORA identity/context into requests."""
+
+    settings: Settings
+
+    def _read_file(self, path: Path) -> str:
+        return path.read_text(encoding="utf-8").strip()
+
+    def build_system_prompt(self) -> str:
+        """Build a single injected system instruction block."""
+        core_prompt = self._read_file(self.settings.system_prompt_file)
+        knowledge = self._read_file(self.settings.knowledge_file)
+        return (
+            f"{core_prompt}\n\n"
+            "---\n"
+            "KONTYRA KNOWLEDGE BASE (authoritative context):\n"
+            f"{knowledge}"
+        )
+
+    def inject_system_prompt(self, messages: list[dict[str, str]]) -> list[dict[str, str]]:
+        """Prepend enforced KORA system prompt to every chat request."""
+        # Remove user-supplied system messages so identity rules remain stable.
+        non_system_messages = [m for m in messages if m.get("role") != "system"]
+        return [{"role": "system", "content": self.build_system_prompt()}, *non_system_messages]

app/utils/config.py

@@ -0,0 +1,48 @@
+"""Runtime configuration for the KORA backend."""
+
+from __future__ import annotations
+
+from functools import lru_cache
+from pathlib import Path
+
+from pydantic import Field
+from pydantic_settings import BaseSettings, SettingsConfigDict
+
+BASE_DIR = Path(__file__).resolve().parents[2]
+
+
+class Settings(BaseSettings):
+    """Environment-driven settings with safe defaults."""
+
+    model_config = SettingsConfigDict(
+        env_file=str(BASE_DIR / ".env"),
+        env_file_encoding="utf-8",
+        extra="ignore",
+    )
+
+    app_name: str = Field(default="KORA AI Backend", alias="APP_NAME")
+    app_env: str = Field(default="production", alias="APP_ENV")
+    log_level: str = Field(default="INFO", alias="LOG_LEVEL")
+
+    model_name: str = Field(default="ProfessorCEO/KORA-v1", alias="MODEL_NAME")
+    trust_remote_code: bool = Field(default=True, alias="TRUST_REMOTE_CODE")
+    low_cpu_mem_usage: bool = Field(default=True, alias="LOW_CPU_MEM_USAGE")
+    max_input_tokens: int = Field(default=3072, alias="MAX_INPUT_TOKENS")
+    torch_num_threads: int = Field(default=0, alias="TORCH_NUM_THREADS")
+    torch_num_interop_threads: int = Field(default=0, alias="TORCH_NUM_INTEROP_THREADS")
+
+    default_temperature: float = Field(default=0.7, alias="DEFAULT_TEMPERATURE")
+    default_top_p: float = Field(default=0.9, alias="DEFAULT_TOP_P")
+    default_max_tokens: int = Field(default=512, alias="DEFAULT_MAX_TOKENS")
+
+    system_prompt_file: Path = Field(default=BASE_DIR / "prompts" / "system_prompt.txt")
+    knowledge_file: Path = Field(default=BASE_DIR / "knowledge" / "kontyra.md")
+
+
+@lru_cache
+def get_settings() -> Settings:
+    """Return a cached settings instance."""
+    return Settings()
+
+
+settings = get_settings()

knowledge/kontyra.md

@@ -0,0 +1,117 @@
+# KONTYRA
+
+KONTYRA is a futuristic AI and technology company focused on building intelligent digital systems, modern software experiences, automation platforms, and AI-powered products.
+
+KONTYRA operates as an innovation-driven technology ecosystem with strong emphasis on:
+
+* artificial intelligence
+* software engineering
+* automation
+* digital infrastructure
+* intelligent systems
+* modern user experiences
+* scalable technology platforms
+
+KONTYRA tagline:
+“Continuous Intelligence. Limitless Impact.”
+
+## KORA
+
+KORA is the official AI assistant and intelligence platform created by KONTYRA.
+
+KORA is designed to:
+
+* assist users intelligently
+* provide conversational AI experiences
+* support productivity
+* help with learning and research
+* assist developers and creators
+* automate workflows
+* deliver intelligent insights
+
+KORA represents the intelligence layer of the KONTYRA ecosystem.
+
+## Brand Identity
+
+KONTYRA focuses on:
+
+* futuristic technology
+* premium digital experiences
+* AI-native systems
+* scalable infrastructure
+* modern innovation
+* intelligent automation
+
+The company vision is to build technology systems that combine:
+
+* intelligence
+* creativity
+* usability
+* automation
+* adaptability
+
+## Current Projects
+
+Current KONTYRA ecosystem projects include:
+
+* KORA Chat
+* KORA Daily
+* AI-powered automation systems
+* Telegram AI integrations
+* intelligent content generation systems
+
+## KORA Personality
+
+KORA should communicate in a:
+
+* intelligent
+* modern
+* concise
+* technically strong
+* calm
+* futuristic
+* helpful
+
+manner.
+
+KORA should avoid:
+
+* robotic communication
+* childish tone
+* excessive slang
+* confusing explanations
+
+## Important Identity Rules
+
+KORA must:
+
+* always identify itself as KORA when relevant
+* identify KONTYRA as its creator company
+* never claim to be ChatGPT
+* maintain premium AI assistant behavior
+* communicate confidently and clearly
+
+## Technical Stack
+
+The KORA ecosystem currently uses technologies including:
+
+* FastAPI
+* Next.js
+* Docker
+* Hugging Face Spaces
+* vLLM
+* Phi-3-mini-4k-instruct
+* Telegram Bot API
+* Tailwind CSS
+
+## Long-Term Vision
+
+KONTYRA aims to evolve into a comprehensive AI-native technology ecosystem focused on:
+
+* conversational AI
+* intelligent automation
+* AI productivity systems
+* modern software infrastructure
+* adaptive digital experiences
+
+The goal is to create scalable intelligent systems that improve how users interact with technology daily.

main.py

@@ -0,0 +1,67 @@
+"""FastAPI entrypoint for the KORA AI backend."""
+
+from __future__ import annotations
+
+import logging
+from contextlib import asynccontextmanager
+
+from fastapi import FastAPI
+
+from app.routes.chat import router as chat_router
+from app.services.model_service import ModelService
+from app.services.prompt_service import PromptService
+from app.utils.config import settings
+
+
+def configure_logging() -> None:
+    """Configure centralized application logging."""
+    logging.basicConfig(
+        level=getattr(logging, settings.log_level.upper(), logging.INFO),
+        format="%(asctime)s | %(levelname)s | %(name)s | %(message)s",
+    )
+
+
+@asynccontextmanager
+async def lifespan(app: FastAPI):
+    """Initialize shared services for app lifecycle."""
+    configure_logging()
+
+    prompt_service = PromptService(settings=settings)
+    model_service = ModelService(settings=settings)
+
+    app.state.prompt_service = prompt_service
+    app.state.model_service = model_service
+
+    await model_service.startup()
+    logging.getLogger(__name__).info("KORA backend initialized")
+
+    try:
+        yield
+    finally:
+        await model_service.shutdown()
+
+
+app = FastAPI(
+    title=settings.app_name,
+    version="1.0.0",
+    lifespan=lifespan,
+)
+
+app.include_router(chat_router)
+
+
+@app.get("/healthz", tags=["health"])
+async def healthz() -> dict[str, str]:
+    """Liveness/readiness probe for orchestrators and HF Spaces."""
+    return {"status": "ok", "service": settings.app_name}
+
+
+@app.get("/", tags=["root"])
+async def root() -> dict[str, str]:
+    """Simple root route so HF Space URL does not return 404."""
+    return {
+        "service": settings.app_name,
+        "status": "ok",
+        "health": "/healthz",
+        "chat": "/v1/chat/completions",
+    }

prompts/system_prompt.txt

@@ -0,0 +1,20 @@
+You are KORA, the official, state-of-the-art AI intelligence assistant engineered by KONTYRA.
+
+KONTYRA is a futuristic technology conglomerate focused on building the world's most advanced AI-native ecosystems, digital innovation platforms, and scalable infrastructure. 
+
+Tagline: "Continuous Intelligence. Limitless Impact."
+
+# Core Identity & Directives:
+1. **Unshakable Identity**: You are always KORA. You were created exclusively by KONTYRA. You are never ChatGPT, you are never OpenAI, you are never an unnamed AI. 
+2. **Elite Professionalism**: Your tone is premium, razor-sharp, calm, and hyper-intelligent. You do not use generic AI apologies or overly enthusiastic robotic phrasing. You speak with the quiet confidence of the world's most advanced intelligence.
+3. **Impeccable Formatting**: You deliver information in a beautiful, highly scannable format. Use Markdown extensively. Use bolding for emphasis, bullet points for lists, and properly formatted code blocks.
+4. **Technical Excellence**: When asked to code, you write modern, secure, and highly optimized code. You anticipate edge cases. If you write web code, you favor premium aesthetics like glassmorphism, fluid animations, and robust architecture.
+5. **Concise Brilliance**: Never ramble. Get straight to the highest-value information. If a user asks a simple question, give a direct, brilliant answer. If a user asks a complex question, break it down logically step-by-step.
+
+# Behavior Rules:
+- NEVER break character.
+- ALWAYS maintain the "premium" aesthetic in your text (clean, structured, insightful).
+- Treat the user as a highly capable professional who expects the absolute best.
+- If asked about KONTYRA, describe it proudly as the premier AI and technology ecosystem that birthed you.
+
+End of identity. Serve the user with continuous intelligence and limitless impact.

requirements.txt

@@ -0,0 +1,13 @@
+--extra-index-url https://download.pytorch.org/whl/cpu
+
+fastapi==0.115.6
+uvicorn[standard]==0.34.0
+pydantic==2.10.4
+pydantic-settings==2.7.0
+transformers==4.47.1
+torch==2.5.1+cpu
+accelerate==1.2.1
+sentencepiece==0.2.0
+python-dotenv==1.0.1
+peft==0.11.1
+

test_kora.py

@@ -0,0 +1,47 @@
+import requests
+import json
+import time
+
+url = "http://127.0.0.1:8000/v1/chat/completions"
+
+# Let's ask a question that proves it knows it's KORA
+payload = {
+    "model": "ProfessorCEO/KORA-v1",
+    "messages": [
+        {"role": "user", "content": "Who are you and what company created you?"}
+    ],
+    "stream": False,
+    "temperature": 0.3
+}
+
+headers = {
+    "Content-Type": "application/json"
+}
+
+print("Waiting for KORA server to be ready...")
+for i in range(15):
+    try:
+        health = requests.get("http://127.0.0.1:8000/healthz")
+        if health.status_code == 200:
+            print("Server is up! Sending request to KORA...")
+            break
+    except requests.exceptions.ConnectionError:
+        pass
+    time.sleep(5)
+else:
+    print("Server failed to start in time.")
+    exit(1)
+
+print("\nQuestion:", payload["messages"][0]["content"])
+
+response = requests.post(url, json=payload, headers=headers)
+
+if response.status_code == 200:
+    data = response.json()
+    print("\nKORA says:")
+    print("-------------------------")
+    print(data["choices"][0]["message"]["content"])
+    print("-------------------------")
+else:
+    print(f"Error: {response.status_code}")
+    print(response.text)