┌─────────────────────────────────────────────────┐
│               Tauri Application                 │
│                                                 │
│  ┌───────────────────────────────────────────┐  │
│  │            Frontend (React)               │  │
│  │                                           │  │
│  │  invoke() ─── Tauri IPC ──▶ Rust Backend  │  │
│  │  fetch()  ─── HTTP ──────▶ Python Sidecar │  │
│  └───────────────────────────────────────────┘  │
│                                                 │
│  ┌─────────────────┐    ┌────────────────────┐  │
│  │  Rust Backend   │    │  Python Sidecar    │  │
│  │                 │    │                    │  │
│  │ • File ops      │    │ • LangGraph agent  │  │
│  │ • System APIs   │    │ • ML inference     │  │
│  │ • Performance   │◄──▶│ • AI pipelines     │  │
│  │ • Process mgmt  │    │ • Data processing  │  │
│  │                 │    │                    │  │
│  │ Spúšťa a riadi  │    │ FastAPI server     │  │
│  │ Python proces   │    │ localhost:8000     │  │
│  └─────────────────┘    └────────────────────┘  │
└─────────────────────────────────────────────────┘

# python-backend/main.py
from fastapi import FastAPI
from langgraph.graph import StateGraph, END
from langchain_openai import ChatOpenAI
import uvicorn

app = FastAPI()

# LangGraph agent definition
def create_agent():
    llm = ChatOpenAI(model="gpt-4o-mini", temperature=0)

    def analyze_node(state):
        """Agent analyzuje vstup a rozhodne sa, čo ďalej"""
        response = llm.invoke(state["messages"])
        return {"messages": state["messages"] + [response]}

    def should_continue(state):
        last_message = state["messages"][-1]
        if hasattr(last_message, "tool_calls") and last_message.tool_calls:
            return "tools"
        return END

    graph = StateGraph(dict)
    graph.add_node("analyze", analyze_node)
    graph.add_conditional_edges("analyze", should_continue)
    graph.set_entry_point("analyze")

    return graph.compile()

agent = create_agent()

@app.post("/api/chat")
async def chat(request: dict):
    """Endpoint pre LangGraph agenta"""
    result = agent.invoke({
        "messages": [("human", request["message"])]
    })
    return {"response": result["messages"][-1].content}

@app.post("/api/analyze-document")
async def analyze_document(request: dict):
    """AI analýza dokumentu"""
    result = agent.invoke({
        "messages": [("human", f"Analyzuj tento dokument: {request['content']}")]
    })
    return {"analysis": result["messages"][-1].content}

@app.get("/health")
async def health():
    return {"status": "ok"}

if __name__ == "__main__":
    uvicorn.run(app, host="127.0.0.1", port=8000)

// src-tauri/src/lib.rs
use tauri::Manager;

#[cfg_attr(mobile, tauri::mobile_entry_point)]
pub fn run() {
    tauri::Builder::default()
        .setup(|app| {
            // Spustenie Python sidecar ako externý binárny súbor
            let sidecar_command = app
                .shell()
                .sidecar("python-backend")
                .expect("Failed to create sidecar command")
                .env("PYTHONUTF8", "1");

            let (mut _rx, _child) = sidecar_command
                .spawn()
                .expect("Failed to spawn python backend");

            println!("Python sidecar started on localhost:8000");
            Ok(())
        })
        .invoke_handler(tauri::generate_handler![
            process_large_file,
            get_system_info,
        ])
        .run(tauri::generate_context!())
        .expect("error while running tauri application");
}

// Rýchle Rust operácie
#[tauri::command]
fn process_large_file(path: String) -> Result<String, String> {
    let content = std::fs::read_to_string(&path)
        .map_err(|e| e.to_string())?;
    Ok(content)
}

{
  "bundle": {
    "externalBin": [
      "binaries/python-backend"
    ]
  },
  "app": {
    "security": {
      "csp": "default-src 'self'; connect-src 'self' http://localhost:8000"
    }
  }
}

// src/App.tsx
import { invoke } from '@tauri-apps/api/core';

function App() {
  // Rust pre rýchle file operácie
  const loadFile = async (path: string) => {
    const content = await invoke<string>('process_large_file', { path });
    return content;
  };

  // Python pre AI analýzu
  const analyzeWithAI = async (content: string) => {
    const response = await fetch('http://localhost:8000/api/analyze-document', {
      method: 'POST',
      headers: { 'Content-Type': 'application/json' },
      body: JSON.stringify({ content }),
    });
    return response.json();
  };

  // Kombinácia: Rust číta súbor → Python analyzuje
  const handleAnalyze = async () => {
    // 1. Rust: Bleskové načítanie súboru
    const content = await loadFile(selectedFile);

    // 2. Python + LangGraph: AI analýza obsahu
    const analysis = await analyzeWithAI(content);

    setResult(analysis);
  };

  return (
    <div>
      <button onClick={handleAnalyze}>
        Analyzuj dokument s AI
      </button>
    </div>
  );
}

┌──────────────────────────────────────────────────┐
│                                                  │
│  RUST (rýchly kôň)          PYTHON (AI mozog)   │
│  ─────────────────           ────────────────    │
│  • File I/O                  • LangGraph agent   │
│  • System APIs               • ML modely         │
│  • Kryptografia              • Data science      │
│  • Paralelné spracovanie     • NLP pipelines     │
│  • Process management        • RAG systémy       │
│  • Sieťové operácie          • Prompt chaining   │
│                                                  │
│  Výkon: ~C/C++ level         Ekosystém: 500k+   │
│  RAM: minimálna              knižníc pre AI/ML   │
│                                                  │
└──────────────────────────────────────────────────┘

# Zbuildujte Python backend do standalone executable
pyinstaller --onefile \
  --name python-backend \
  --hidden-import=uvicorn \
  --hidden-import=langgraph \
  python-backend/main.py

# Výsledok: dist/python-backend.exe (~50-80 MB)
# Skopírujte do Tauri binaries
cp dist/python-backend src-tauri/binaries/python-backend-x86_64-pc-windows-msvc

# Build Tauri appky (vrátane Python sidecar)
npm run tauri build

# Výsledok:
# src-tauri/target/release/bundle/
# ├── msi/YourApp_1.0.0_x64.msi     (~60-90 MB)
# └── nsis/YourApp_1.0.0_x64-setup.exe