BYTEBOOK | Ghid Rulare Model AI (LLM) în Python

# Modele Mici Recomandate pentru VPS fără GPU (CPU-only)

Qwen2.5-0.5B-Instruct ~350-500 MB RAM

Ultra-rapid, recomandat pentru sarcini simple de text/JSON.

SmolLM2-360M-Instruct ~300 MB RAM

Creat special pentru dispozitive cu resurse reduse.

Qwen2.5-1.5B-Instruct ~1.2 GB RAM

Mai inteligent, capabil de raționament mai avansat.

1. Metoda 1: Rulare Nativă cu Hugging Face transformers

A. Pregătirea Mediului Virtual Python

ssh root@63.250.40.142
mkdir -p /root/projects/python-ai
cd /root/projects/python-ai
python3 -m venv venv
source venv/bin/activate

pip install --upgrade pip
pip install torch transformers accelerate

B. Scriptul de Test CLI (run_ai.py)

nano run_ai.py

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

model_name = "Qwen/Qwen2.5-0.5B-Instruct"

print(f"Loading model '{model_name}' on CPU...")

tokenizer = AutoTokenizer.from_pretrained(model_name)
model = AutoModelForCausalLM.from_pretrained(
    model_name,
    torch_dtype=torch.float32,
    device_map="cpu"
)

def generate_response(prompt_text):
    messages = [
        {"role": "system", "content": "Ești un asistent AI util și concis."},
        {"role": "user", "content": prompt_text}
    ]

    text = tokenizer.apply_chat_template(
        messages,
        tokenize=False,
        add_generation_prompt=True
    )

    model_inputs = tokenizer([text], return_tensors="pt").to("cpu")

    generated_ids = model.generate(
        **model_inputs,
        max_new_tokens=256,
        temperature=0.7,
        do_sample=True
    )

    generated_ids = [
        output_ids[len(input_ids):] for input_ids, output_ids in zip(model_inputs.input_ids, generated_ids)
    ]

    response = tokenizer.batch_decode(generated_ids, skip_special_tokens=True)[0]
    return response

if __name__ == "__main__":
    prompt = "Explică într-o propoziție ce este un microserviciu."
    print(f"\nÎntrebare: {prompt}")
    print("AI Răspuns:", generate_response(prompt))

python run_ai.py

2. Metoda 2: Expunerea Modelului AI ca API REST cu FastAPI

Pentru a putea apela AI-ul din aplicațiile tale (Java, Node.js, React sau Angular), vom crea un Microserviciu cu FastAPI.

A. Instalare FastAPI & Uvicorn

pip install fastapi uvicorn

B. Crearea fișierului main.py

nano main.py

from fastapi import FastAPI, HTTPException
from pydantic import BaseModel
import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

app = FastAPI(title="Python Local AI API")

MODEL_NAME = "Qwen/Qwen2.5-0.5B-Instruct"
print("Loading AI Model...")
tokenizer = AutoTokenizer.from_pretrained(MODEL_NAME)
model = AutoModelForCausalLM.from_pretrained(
    MODEL_NAME,
    torch_dtype=torch.float32,
    device_map="cpu"
)
print("Model AI încărcat cu succes!")

class ChatRequest(BaseModel):
    prompt: str
    system_prompt: str = "Ești un asistent AI util."
    max_tokens: int = 200

@app.get("/")
def root():
    return {"status": "online", "model": MODEL_NAME}

@app.post("/api/generate")
def generate_ai_text(req: ChatRequest):
    try:
        messages = [
            {"role": "system", "content": req.system_prompt},
            {"role": "user", "content": req.prompt}
        ]

        text = tokenizer.apply_chat_template(
            messages,
            tokenize=False,
            add_generation_prompt=True
        )

        model_inputs = tokenizer([text], return_tensors="pt").to("cpu")

        generated_ids = model.generate(
            **model_inputs,
            max_new_tokens=req.max_tokens,
            temperature=0.7,
            do_sample=True
        )

        generated_ids = [
            output_ids[len(input_ids):] for input_ids, output_ids in zip(model_inputs.input_ids, generated_ids)
        ]

        response_text = tokenizer.batch_decode(generated_ids, skip_special_tokens=True)[0]

        return {
            "prompt": req.prompt,
            "response": response_text
        }
    except Exception as e:
        raise HTTPException(status_code=500, detail=str(e))

C. Testare Locală API

uvicorn main:app --host 0.0.0.0 --port 8090

Într-un alt terminal:

curl -X POST http://localhost:8090/api/generate \
     -H "Content-Type: application/json" \
     -d '{"prompt": "Scrie un salut scurt pentru comunitatea Bytebook."}'

3. Expunerea API-ului AI prin Caddy Reverse Proxy

Pentru a accesa API-ul AI prin HTTPS pe subdomeniul ai.bytebook.xyz:

Configurare Namecheap: Adaugă un A Record (Host: ai, Value: 63.250.40.142).
Editează /etc/caddy/Caddyfile:
```
nano /etc/caddy/Caddyfile
```

Adaugă blocul de configurare:

ai.bytebook.xyz {
    reverse_proxy localhost:8090
}

Reîncarcă Caddy:
```
systemctl reload caddy
```

4. Rularea API-ului AI 24/7 ca Serviciu systemd

Creează fișierul de serviciu:

nano /etc/systemd/system/python-ai.service

Adaugă următoarea configurație:

[Unit]
Description=Python AI Local LLM Service
After=network.target

[Service]
Type=simple
User=root
WorkingDirectory=/root/projects/python-ai
ExecStart=/root/projects/python-ai/venv/bin/uvicorn main:app --host 127.0.0.1 --port 8090
Restart=always
RestartSec=5

[Install]
WantedBy=multi-user.target

Activează, pornește și verifică serviciul:

systemctl daemon-reload
systemctl enable --now python-ai
systemctl status python-ai

# Metoda 3: Varianta Ultra-Optimizată GGUF (cu llama-cpp-python)

Dacă dorești viteze de procesare de 2-3 ori mai mari și consum extrem de redus de memorie (sub 300MB RAM), poți folosi formatul quantizat GGUF:

Instalează llama-cpp-python:
```
pip install llama-cpp-python
```

Descarcă modelul GGUF:

wget https://huggingface.co/Qwen/Qwen2.5-0.5B-Instruct-GGUF/resolve/main/qwen2.5-0.5b-instruct-q4_k_m.gguf -O model.gguf

Script de rulare rapid în Python: