Architektura Systemu - emielregis2/SmartFlowAI GitHub Wiki

Architektura Systemu - SmartFlowAI

Poznaj techniczną strukturę SmartFlowAI - od frontendu po integracje AI! 🏗️

🎯 Przegląd architektury

SmartFlowAI to monolityczna aplikacja Streamlit z zewnętrznymi integracjami. Architektura została zaprojektowana dla szybkiego rozwoju i łatwego wdrożenia.

┌─────────────────┐    ┌─────────────────┐    ┌─────────────────┐
│   Frontend      │    │   Backend       │    │   External      │
│   (Streamlit)   │◄──►│   (Python)      │◄──►│   Services      │
└─────────────────┘    └─────────────────┘    └─────────────────┘
│                      │                      │
├─ UI Components      ├─ Business Logic      ├─ Supabase DB
├─ Forms & Widgets    ├─ Data Processing    ├─ OpenAI API
├─ State Management   ├─ PDF Generation     └─ Web Search
└─ Session Handling   └─ Authentication

🏗️ Komponenty systemu

1. Frontend (Streamlit)

Plik: streamlit_app.py (1336 linii)

Główne sekcje:

  • Authentication - Logowanie i rejestracja
  • Dashboard - Główny panel użytkownika
  • Process Management - CRUD operacje na procesach
  • AI Analysis - Interfejs do analizy procesów
  • Export/Reports - Generowanie PDF i raportów

Kluczowe funkcje UI:

def show_login()           # Formularz logowania
def show_dashboard()       # Główny dashboard
def show_add_process()     # Dodawanie nowego procesu
def show_process_list()    # Lista procesów użytkownika
def show_edit_process()    # Edycja istniejącego procesu

2. Backend (Python Functions)

Zarządzanie danymi:

def save_process()         # Zapisz proces do bazy
def get_processes()        # Pobierz procesy użytkownika
def update_process()       # Aktualizuj proces
def delete_process()       # Usuń proces

Analiza AI:

def analyze_process_with_ai()  # Główna funkcja analizy
def create_analysis_prompt()  # Generowanie promptu
def init_openai()             # Inicjalizacja OpenAI

Export i raporty:

def generate_pdf_report()     # Generowanie PDF
def generate_text_report()    # Generowanie tekstu
def copy_to_clipboard()       # Kopiowanie do schowka

3. Baza danych (Supabase PostgreSQL)

Schemat tabel:

-- Użytkownicy
CREATE TABLE users (
    id UUID PRIMARY KEY DEFAULT gen_random_uuid(),
    email VARCHAR(255) UNIQUE NOT NULL,
    password_hash VARCHAR(255) NOT NULL,
    full_name VARCHAR(255),
    created_at TIMESTAMPTZ DEFAULT NOW(),
    updated_at TIMESTAMPTZ DEFAULT NOW()
);

-- Procesy biznesowe
CREATE TABLE business_processes (
    id UUID PRIMARY KEY DEFAULT gen_random_uuid(),
    user_id UUID REFERENCES users(id) ON DELETE CASCADE,
    title VARCHAR(500) NOT NULL,
    description TEXT NOT NULL,
    ai_analysis TEXT,
    analysis_depth VARCHAR(50),
    company_size VARCHAR(50),
    industry VARCHAR(100),
    budget_range VARCHAR(50),
    automation_potential INTEGER,
    time_savings_hours DECIMAL(10,2),
    cost_savings_annual DECIMAL(12,2),
    implementation_difficulty VARCHAR(50),
    created_at TIMESTAMPTZ DEFAULT NOW(),
    updated_at TIMESTAMPTZ DEFAULT NOW()
);

-- Kategorie procesów
CREATE TABLE process_categories (
    id UUID PRIMARY KEY DEFAULT gen_random_uuid(),
    name VARCHAR(100) NOT NULL,
    description TEXT,
    industry VARCHAR(100),
    typical_tools TEXT[],
    created_at TIMESTAMPTZ DEFAULT NOW()
);

-- Logi aktywności
CREATE TABLE activity_logs (
    id UUID PRIMARY KEY DEFAULT gen_random_uuid(),
    user_id UUID REFERENCES users(id) ON DELETE CASCADE,
    action VARCHAR(100) NOT NULL,
    resource_type VARCHAR(50),
    resource_id UUID,
    details JSONB,
    created_at TIMESTAMPTZ DEFAULT NOW()
);

4. Zewnętrzne integracje

OpenAI GPT-4o

# Konfiguracja
openai.api_key = os.getenv("OPENAI_API_KEY")

# Wywołanie API
response = openai.ChatCompletion.create(
    model="gpt-4o",
    messages=[{"role": "user", "content": prompt}],
    temperature=0.7,
    max_tokens=2000
)

Supabase Client

# Inicjalizacja
supabase = create_client(
    url=os.getenv("SUPABASE_URL"),
    key=os.getenv("SUPABASE_SERVICE_ROLE_KEY")
)

# Operacje CRUD
result = supabase.table('business_processes').insert(data).execute()

🔄 Przepływ danych

1. Dodawanie nowego procesu

User Input → Streamlit Form → Validation → Database Insert → AI Analysis → Update Record

2. Analiza AI

Process Data → Prompt Generation → OpenAI API → Response Processing → Database Update → UI Display

3. Export PDF

Process List → Data Formatting → PDF Generation (fpdf2) → File Download

📁 Struktura plików

SmartFlowAI/
├── streamlit_app.py              # Główna aplikacja (1336 linii)
├── requirements.txt              # Zależności Python
├── .streamlit/
│   ├── secrets.toml             # Konfiguracja (klucze API)
│   └── config.toml              # Ustawienia Streamlit
├── supabase_setup.sql           # Skrypt inicjalizacji bazy
├── disable_rls_for_development.sql  # Wyłączenie RLS
├── tests/
│   ├── test_app.py              # Testy podstawowe
│   ├── test_comprehensive.py    # Testy kompleksowe
│   ├── test_e2e.py             # Testy end-to-end
│   └── test_production_ready.py # Testy produkcyjne
├── .github/workflows/
│   ├── ci.yml                   # CI/CD pipeline
│   └── pr.yml                   # Pull request checks
└── docs/
    ├── README.md                # Dokumentacja główna
    ├── CO_ROBI_TEN_PROGRAM.md  # Opis funkcjonalności
    └── CHANGELOG.md             # Historia zmian

🔧 Konfiguracja środowiska

Zmienne środowiskowe

# .streamlit/secrets.toml
SUPABASE_URL = "https://projekt.supabase.co"
SUPABASE_ANON_KEY = "anon_key"
SUPABASE_SERVICE_ROLE_KEY = "service_role_key"
OPENAI_API_KEY = "sk-openai_key"
DEMO_MODE = false

Zależności Python

# requirements.txt
streamlit>=1.28.0
supabase>=2.0.0
openai>=1.0.0
fpdf2>=2.7.0
python-dotenv>=1.0.0
pandas>=2.0.0
requests>=2.31.0

🚀 Deployment

Streamlit Cloud

  1. Połączenie z GitHub - Automatyczne wykrywanie zmian
  2. Secrets Management - Bezpieczne przechowywanie kluczy API
  3. Auto-deployment - Każdy push do main branch

Lokalne uruchomienie

# Instalacja zależności
pip install -r requirements.txt

# Uruchomienie aplikacji
streamlit run streamlit_app.py

🔒 Bezpieczeństwo

Row Level Security (RLS)

-- Polityki bezpieczeństwa
CREATE POLICY "Users can view own processes" 
ON business_processes FOR SELECT 
USING (user_id = auth.uid());

CREATE POLICY "Users can insert own processes" 
ON business_processes FOR INSERT 
WITH CHECK (user_id = auth.uid());

Walidacja danych

def validate_process_input(title, description):
    if not title or len(title.strip()) < 3:
        return False, "Tytuł musi mieć minimum 3 znaki"
    if not description or len(description.strip()) < 10:
        return False, "Opis musi mieć minimum 10 znaków"
    return True, ""

📊 Monitoring i logi

Logowanie

import logging

logging.basicConfig(
    level=logging.INFO,
    format='%(asctime)s - %(name)s - %(levelname)s - %(message)s'
)
logger = logging.getLogger(__name__)

Metryki

  • Czas odpowiedzi AI - Monitoring wywołań OpenAI
  • Błędy bazy danych - Tracking failed queries
  • Aktywność użytkowników - Logi w tabeli activity_logs

🔄 Skalowanie

Obecne ograniczenia

  • Single-threaded - Streamlit nie obsługuje wielowątkowości
  • Memory-bound - Wszystkie dane w pamięci sesji
  • No caching - Brak cache'owania wyników AI

Możliwe ulepszenia

  • Redis cache - Cache'owanie wyników AI
  • Background jobs - Asynchroniczna analiza procesów
  • Load balancing - Wiele instancji aplikacji
  • Database optimization - Indeksy i optymalizacja zapytań

Następny krok: API i Integracje - poznaj szczegóły integracji z zewnętrznymi serwisami.