softreck/WronAI

🚀 Minimalne LLM + Własny Model - Kompletny Guide

🎯 CZĘŚĆ 1: Uruchomienie w 2 minuty

Szybki start (minimalne rozwiązanie)

# 1. Sklonuj pliki
git clone <your-repo>
cd minimal-llm

# 2. Uruchom wszystko jedną komendą
chmod +x quick-start.sh
./quick-start.sh

# 3. Otwórz przeglądarkę
# http://localhost:8501 - Streamlit UI
# http://localhost:11434 - Ollama API

Co się dzieje pod spodem?

• Ollama - pobiera i uruchamia Mistral 7B
• Streamlit - prosty chat interface
• Docker - wszystko w kontenerach
• Minimalne zależności - tylko 3 pakiety Python!

📁 Struktura projektu (minimalna)

minimal-llm/
├── docker-compose.yml       # 1 plik - cała infrastruktura
├── Dockerfile              # Minimalne image
├── requirements.txt         # 3 pakiety
├── quick-start.sh          # 1 komenda = pełny setup
└── app/
    └── main.py             # 50 linijek = pełny chat

🎯 CZĘŚĆ 2: Stwórz własny model LLM

Krok 1: Przygotowanie środowiska

# Instalacja zależności do fine-tuningu
pip install -r model_requirements.txt

# Login do Hugging Face (do publikacji)
huggingface-cli login

Krok 2: Przygotowanie danych

python create_custom_model.py
# Wybierz opcję 1: Stwórz sample dataset

Przykład danych treningowych:

[
  {
    "instruction": "Jak nazywa się stolica Polski?",
    "input": "",
    "output": "Stolica Polski to Warszawa."
  },
  {
    "instruction": "Wyjaśnij czym jest sztuczna inteligencja",
    "input": "",
    "output": "Sztuczna inteligencja (AI) to dziedzina informatyki..."
  }
]

Krok 3: Fine-tuning modelu

# Uruchom fine-tuning (wymaga GPU)
python create_custom_model.py
# Wybierz opcję 2: Fine-tune model

# Lub pełny pipeline
python create_custom_model.py
# Wybierz opcję 6: Pełny pipeline

Optymalizacje dla RTX 3050:

• 4-bit quantization
• LoRA (Low-Rank Adaptation)
• Batch size = 1
• Gradient accumulation = 4
• Mixed precision (FP16)

Krok 4: Konwersja do GGUF

# Automatycznie generowany skrypt
./convert_to_gguf.sh

Krok 5: Stworzenie modelu w Ollama

# Utwórz Modelfile
python create_custom_model.py  # wybierz opcję 4

# Stwórz model w Ollama
ollama create wronai -f Modelfile

# Uruchom model
ollama run wronai

Uruchamianie skryptu

Skrypt create_custom_model.py oferuje interaktywne menu z następującymi opcjami:

python create_custom_model.py

Dostępne opcje:

1. Stwórz przykładowy dataset
2. Wykonaj fine-tuning modelu
3. Konwertuj model do formatu GGUF
4. Utwórz Modelfile dla Ollama
5. Opublikuj model na Hugging Face
6. Wykonaj pełny pipeline (1-5)

Wymagania wstępne

• Python 3.8+
• PyTorch z obsługą CUDA (zalecane)
• Biblioteki wymienione w model_requirements.txt
• Konto na Hugging Face (do publikacji modelu)

Rozwiązywanie problemów

Błąd składni w skrypcie

Jeśli napotkasz błąd składni, upewnij się, że:

1. Używasz Pythona 3.8 lub nowszego
2. Wszystkie zależności są zainstalowane
3. Plik nie został uszkodzony podczas pobierania

Problemy z zależnościami

# Utwórz i aktywuj środowisko wirtualne
python -m venv .venv
source .venv/bin/activate  # Linux/Mac
.venv\Scripts\activate    # Windows

# Zainstaluj zależności
pip install -r model_requirements.txt

Brakujące uprawnienia

Jeśli napotkasz problemy z uprawnieniami, spróbuj:

# Nadaj uprawnienia do wykonywania skryptów
chmod +x *.sh

# Uruchom z uprawnieniami administratora (jeśli potrzebne)
sudo python create_custom_model.py

Kontrybucja

Zapraszamy do zgłaszania problemów i propozycji zmian poprzez Issues i Pull Requests.

Test modelu

ollama run wronai "Cześć! Kim jesteś?"

### Krok 6: Publikacja modelu

#### **Opcja A: Ollama Registry**
```bash
# Push do Ollama Library
ollama push wronai

# Teraz każdy może użyć:
ollama pull your-username/wronai

Opcja B: Hugging Face Hub

# Publikacja na HF
python publish_to_hf.py

# Model dostępny na:
# https://huggingface.co/your-username/my-custom-mistral-7b

Opcja C: Docker Registry

# Spakuj do Docker image
docker build -t my-custom-llm .
docker tag my-custom-llm your-registry/my-custom-llm
docker push your-registry/my-custom-llm

🎯 CZĘŚĆ 3: Gotowe alternatywy (zero kodu)

1. Najprostsze - Ollama

# Instalacja
curl -fsSL https://ollama.ai/install.sh | sh

# Uruchomienie modelu
ollama run mistral:7b-instruct

# API automatycznie na localhost:11434

2. Hugging Face Inference API

import requests

headers = {"Authorization": "Bearer YOUR_HF_TOKEN"}
response = requests.post(
    "https://api-inference.huggingface.co/models/mistralai/Mistral-7B-Instruct-v0.1",
    headers=headers,
    json={"inputs": "Hello!"}
)

3. Groq (ultra szybkie)

from openai import OpenAI

client = OpenAI(
    api_key="YOUR_GROQ_KEY",
    base_url="https://api.groq.com/openai/v1"
)

response = client.chat.completions.create(
    model="mistral-7b-instruct",
    messages=[{"role": "user", "content": "Hello!"}]
)

4. Together.ai

from openai import OpenAI

client = OpenAI(
    api_key="YOUR_TOGETHER_KEY",
    base_url="https://api.together.xyz/v1"
)

# Kompatybilne z OpenAI API

5. Modal.com (serverless GPU)

import modal

stub = modal.Stub("llm-api")

@stub.function(gpu="T4")
def generate(prompt: str):
    # Twój kod modelu
    return model.generate(prompt)

# Deploy jedną komendą
# modal deploy

🎯 CZĘŚĆ 4: Frontend opcje

1. Streamlit (Python)

import streamlit as st

st.title("My LLM Chat")
prompt = st.text_input("Message:")
if st.button("Send"):
    response = generate(prompt)
    st.write(response)

2. Gradio (Python)

import gradio as gr

def chat(message, history):
    response = generate(message)
    history.append([message, response])
    return "", history

gr.ChatInterface(chat).launch()

3. Next.js + Vercel AI SDK

import { useChat } from 'ai/react'

export default function Chat() {
  const { messages, input, handleInputChange, handleSubmit } = useChat()
  
  return (
    <div>
      {messages.map(m => <div key={m.id}>{m.content}</div>)}
      <form onSubmit={handleSubmit}>
        <input value={input} onChange={handleInputChange} />
      </form>
    </div>
  )
}

🎯 CZĘŚĆ 5: Porównanie rozwiązań

Rozwiązanie	Setup Time	Kód	Hosting	GPU
Ollama + Streamlit	2 min	50 linijek	Local/Docker	Optional
Hugging Face API	30 sec	5 linijek	Cloud	No
Groq API	1 min	5 linijek	Cloud	No
Modal.com	5 min	20 linijek	Serverless	Auto
Custom Fine-tuning	2 hours	200 linijek	Self-hosted	Required

🛠️ Debugging & Tips

Typowe problemy

# Model nie ładuje się
docker logs ollama-engine

# Brak GPU
docker run --rm --gpus all nvidia/cuda:11.8-base nvidia-smi

# Port zajęty
sudo netstat -tlnp | grep 11434

# Restart wszystkiego
docker compose down && docker compose up -d

Optymalizacje RTX 3050

# W fine-tuningu
model = AutoModelForCausalLM.from_pretrained(
    model_name,
    load_in_4bit=True,        # 4-bit quantization
    torch_dtype=torch.float16 # Half precision
)

# Training args
TrainingArguments(
    per_device_train_batch_size=1,   # Mały batch
    gradient_accumulation_steps=4,   # Gradients accumulation
    fp16=True                        # Mixed precision
)

Monitoring zasobów

# GPU monitoring
watch -n 1 nvidia-smi

# Container resources
docker stats

# Model memory usage
docker exec -it ollama-engine ollama ps

🎯 Następne kroki

Dla nauki:

1. Eksperymentuj z różnymi modelami - Llama, CodeLlama, Phi-3
2. Testuj różne techniki fine-tuningu - LoRA, QLoRA, Full fine-tuning
3. Dodaj RAG - Retrieval Augmented Generation
4. Stwórz multi-agent system

Dla produkcji:

1. Przejdź na managed service - Groq, Together.ai
2. Setup monitoring - LangSmith, Weights & Biases
3. Dodaj cache - Redis dla odpowiedzi
4. Implement rate limiting

Dla biznesu:

1. Fine-tune na własnych danych
2. Setup A/B testing różnych modeli
3. Dodaj feedback loop od użytkowników
4. Monetize API

🎉 Podsumowanie

Wybierz opcję według potrzeb:

• Demo/nauka: Ollama + Streamlit (to rozwiązanie)
• Prototyp: Hugging Face API + Gradio
• MVP: Groq API + Next.js
• Produkcja: Modal/RunPod + custom frontend
• Enterprise: Fine-tuned model + własna infrastruktura

Minimalne rozwiązanie = 5 plików, 50 linijek kodu, 2 minuty setup!