Sign in Subscribe
By DevOps —

PyCharm + Windsurf

PyCharm + Windsurf
Photo by Wolfgang Hasselmann / Unsplash

🚀 PyCharm Community + Windsurf Plugin Installation

HP Z420 Workstation - Debian 12/13 Setup Guide (Oktober 2025)

System: HP Z420 (2011-2013 Generation)
Hardware: Intel Xeon E5-2697 v2 (12C/24T), 128GB ECC RAM, RTX 5060 Ti 16GB
OS: Debian 12 Bookworm oder Debian 13 (Trixie)
Ziel: Beste Hybrid-Lösung für 120-Dateien-Refactoring mit CCC CODE

📖 Überblick: Warum diese Kombination?

✅ Die neue Realität (Oktober 2025):

Was sich geändert hat:

  • ✅ OpenAI gpt-oss-20b läuft lokal auf 16GB GPU (Aug 2025!)
  • ✅ GPT-5 ist 40% günstiger als Claude (SWE-bench King: 74.9%)
  • ✅ Claude Sonnet 4.5 schafft 30h autonome Coding-Sessions
  • ✅ Hybrid-Setup ist jetzt optimal: Lokal (90%) + Cloud (10%) = $20/Monat

🎯 Perfekt für:

  • Großes Python-Refactoring (120+ Dateien im CCC CODE)
  • Cement Framework Migration (v2 → v3)
  • Namespace-Änderungen über viele Dateien
  • AI-unterstützte Code-Analyse (lokal + Cloud)

💡 Die Drei Säulen:

┌──────────────────────────────────────────────┐
│ SÄULE 1: PyCharm Community (Refactoring)    │
│ → Safe Rename über 120+ Dateien             │
│ → Kostenfrei, beste Python-IDE               │
├──────────────────────────────────────────────┤
│ SÄULE 2: Windsurf Plugin (AI-Integration)   │
│ → Cascade Agent für Multi-File-Edits        │
│ → MCP Server Support für alle APIs           │
├──────────────────────────────────────────────┤
│ SÄULE 3: Hybrid AI-Stack                    │
│ → 90%: gpt-oss-20b (lokal, \$0)              │
│ → 8%: GPT-5 (Cloud, Frontend/Complex)       │
│ → 2%: Claude Sonnet 4.5 (Refactoring)       │
└──────────────────────────────────────────────┘

Total Cost: ~\$20/Monat + Strom
Total Capability: Frontier-Level

⚙️ Teil 1: System-Vorbereitung

1.1 System aktualisieren

# System auf neuesten Stand bringen
sudo apt update && sudo apt upgrade -y

# Basis-Pakete installieren
sudo apt install dirmngr ca-certificates software-properties-common \
                 apt-transport-https curl lsb-release -y

# Python-Abhängigkeiten installieren
sudo apt install python3 python3-dev python3-distutils python3-venv -y

# Git installieren (falls noch nicht vorhanden)
sudo apt install git wget gpg -y

# Build-Tools für Compile-Tasks
sudo apt install build-essential -y

1.2 NVIDIA GPU Setup (für gpt-oss-20b)

# GPU-Status prüfen
lspci | grep -i nvidia
# Sollte: NVIDIA Corporation [NVIDIA GPU Model] anzeigen

# NVIDIA-Treiber installieren (Debian 12/13)
sudo apt install nvidia-driver nvidia-cuda-toolkit -y

# ⚠️ WICHTIG: Neustart erforderlich!
sudo reboot

# Nach Neustart: GPU testen
nvidia-smi
# Erwartete Ausgabe:
# +-----------------------------------------------------------------------------+
# | NVIDIA-SMI 535.xx.xx    Driver Version: 535.xx.xx    CUDA Version: 12.2  |
# |-------------------------------+----------------------+----------------------+
# | GPU  Name        Persistence-M| Bus-Id        Disp.A | Volatile Uncorr. ECC |
# | Fan  Temp  Perf  Pwr:Usage/Cap|         Memory-Usage | GPU-Util  Compute M. |
# |===============================+======================+======================|
# |   0  NVIDIA GeForce ...  Off  | 00000000:01:00.0 Off |                  N/A |
# | 30%   45C    P8    15W / 200W |      0MiB / 16384MiB |      0%      Default |
# +-------------------------------+----------------------+----------------------+

# VRAM prüfen (sollte ≥16GB sein für gpt-oss-20b)
nvidia-smi --query-gpu=memory.total --format=csv,noheader
# Erwartete Ausgabe: 16384 MiB oder mehr

Hardware-Anforderungen für gpt-oss-20b:

  • ✅ RTX 5060 Ti (16GB) ← Deine GPU! Perfect! 🎯
  • ✅ RTX 4070 Ti Super (16GB)
  • ✅ RTX 4080 (16GB)
  • ✅ RTX 4090 (24GB)
  • ❌ RTX 3080 (10GB) ← Zu wenig!

🐍 Teil 2: PyCharm Community Installation

2.1 Installation via APT (Empfohlen für Debian!)

✅ Warum APT statt Snap?

  • ✅ Native Debian-Integration - keine Sandboxing-Probleme
  • ✅ Bessere Performance - direkter System-Zugriff
  • ✅ Automatische Updates via apt upgrade
  • ✅ Standard Paketmanagement - kein zusätzliches Snap-System

🔒 Methode 1: JetBrains PPA (Primär, für Debian 12/13)

# 1. GPG-Schlüssel importieren
curl -s https://s3.eu-central-1.amazonaws.com/jetbrains-ppa/0xA6E8698A.pub.asc | \
  gpg --dearmor | \
  sudo tee /usr/share/keyrings/jetbrains-ppa-archive-keyring.gpg > /dev/null

# 2. Repository hinzufügen
echo "deb [signed-by=/usr/share/keyrings/jetbrains-ppa-archive-keyring.gpg] \
  http://jetbrains-ppa.s3-website.eu-central-1.amazonaws.com any main" | \
  sudo tee /etc/apt/sources.list.d/jetbrains-ppa.list > /dev/null

# 3. Paketliste aktualisieren
sudo apt update

# 4. PyCharm Community installieren
sudo apt install pycharm-community -y

# 5. Installation prüfen
apt list --installed | grep pycharm
# Erwartete Ausgabe:
# pycharm-community/any,now 2025.1-xxx amd64 [installiert]

# 6. Version prüfen
pycharm-community --version

🎁 Methode 2: Toolbox App (Alternative, offiziell von JetBrains)

Falls du mehrere JetBrains IDEs nutzen möchtest:

# 1. Toolbox App herunterladen
cd ~/Downloads
wget https://download.jetbrains.com/toolbox/jetbrains-toolbox-2.6.0.tar.gz

# 2. Entpacken
tar -xzf jetbrains-toolbox-*.tar.gz

# 3. Ausführen
cd jetbrains-toolbox-*/
./jetbrains-toolbox

# 4. In Toolbox App: PyCharm Community installieren
# (GUI-basiert, sehr einfach)

⚠️ Methode 3: Snap (Fallback, falls APT Probleme macht)

# Nur falls APT-Installation fehlschlägt!
sudo apt install snapd -y
sudo snap install pycharm-community --classic

# Nachteil: Snap hat Sandboxing-Einschränkungen!

2.2 PyCharm starten & erste Konfiguration

# Via APT installiert:
pycharm-community

# Via Snap installiert:
/snap/bin/pycharm-community

# Oder über Anwendungsmenü:
# Anwendungen → Entwicklung → PyCharm Community Edition

Bei erstem Start:

  1. User Agreement: Akzeptieren
  2. Data Sharing: "Don't Send" (empfohlen für Privacy)
  3. Theme: Wähle Darcula (dunkles Theme, augenschonend)
  4. Keymap: Default belassen
  5. Featured Plugins: Später installieren (überspringen)

2.3 Python-Interpreter konfigurieren

# Projekt öffnen (z.B. CCC CODE)
cd ~/Development
git clone https://github.com/collective-context/ccc-code.git
pycharm-community ~/Development/ccc-code

# In PyCharm:
# 1. File → Settings → Project → Python Interpreter
# 2. ⚙️ → Add → System Interpreter
# 3. Wähle: /usr/bin/python3
# 4. OK → Apply

# Oder: Virtual Environment erstellen
# Settings → Project → Python Interpreter → Add
# → Virtualenv Environment → Location: ~/Development/ccc-code/venv

🌊 Teil 3: Windsurf Plugin Installation

3.1 Plugin über Marketplace installieren

In PyCharm:

1. Settings öffnen: Strg+Alt+S (oder File → Settings)
2. Plugins → Marketplace Tab
3. Suche: "Windsurf" eingeben
4. Klick auf "Install" beim "Windsurf Plugin (formerly Codeium)"
5. "Restart IDE" klicken wenn aufgefordert

⚠️ Falls nicht gefunden:

  • Alternative Suche: "Codeium" (alter Name)
  • Plugin-ID: 20540 (für manuelle Installation)
  • Direct Link: https://plugins.jetbrains.com/plugin/20540-windsurf

3.2 Language Server Download

Nach Plugin-Installation und IDE-Neustart:

  • Windsurf lädt automatisch den Language Server herunter
  • Dauer: ~10-30 Sekunden (abhängig von Internetverbindung)
  • Fortschritt wird unten rechts in der Status-Bar angezeigt

Erwartete Notifications:

1. "Windsurf: Downloading language server..."
2. "Windsurf: Language server ready!"
3. Status-Icon unten rechts: Grüner Haken ✓

3.3 Windsurf Login & Account Setup

Schritt 1: Login-Prompt

  • Erscheint automatisch nach Language Server Download
  • Alternativ: Windsurf Icon unten rechts klicken → "Sign In"

Schritt 2: Browser-Login

  • Browser öffnet sich automatisch: https://windsurf.com/login
  • Wähle Login-Methode:
    • ✅ Google-Account (schnellste Methode)
    • ✅ GitHub-Account (für Entwickler empfohlen)
    • ✅ Email + Passwort

Schritt 3: Zurück zu PyCharm

  • Nach erfolgreichem Login: Browser schließen
  • PyCharm zeigt: "Windsurf: Successfully signed in!"
  • Status-Icon unten rechts: Grünes Windsurf-Symbol ✓

3.4 Cascade AI Chat öffnen

Methode 1: Keyboard Shortcut (schnellste)

Strg+Shift+P (oder Cmd+Shift+P auf Mac)
→ "Windsurf" in Command Palette eingeben
→ "Windsurf: Open Chat" auswählen

Methode 2: Toolbar Icon

  • Unten rechts in der Status-Bar: Windsurf Icon klicken
  • Oder: Rechte Sidebar → Windsurf Tab

Methode 3: Context Menu

  • Rechtsklick im Editor
  • "Windsurf" → "Open Chat"

Erwartetes Ergebnis:

✅ Cascade AI Chat Panel öffnet sich (rechte Sidebar)
✅ "Ready to assist!" Nachricht erscheint
✅ Model-Auswahl oben: "Select Model" Dropdown

🔧 Teil 4: API-Integration (Das Herzstück!)

4.1 Die drei Setup-Strategien

Strategie 1: HYBRID (Empfohlen für HP Z420!)

Kosten: ~$20/Monat + Strom (~€30-75)
Best for: Balance zwischen Privacy & Cloud-Power

PRIMARY (90% Tasks):
└─ gpt-oss-20b (Lokal via Ollama)
   • Cost: $0 API
   • Privacy: 100%
   • Speed: 120-180 tok/sec
   • Hardware: RTX 5060 Ti 16GB ✓

FALLBACK 1 (8% Complex Tasks):
└─ GPT-5 (Cloud API)
   • Cost: ~$15/Monat
   • SWE-bench: 74.9%
   • Best for: Frontend, Tool-Calling

FALLBACK 2 (2% Ultra-Complex):
└─ Claude Sonnet 4.5 (Cloud API)
   • Cost: ~$5/Monat
   • 30h Autonomie
   • Best for: Multi-File Refactoring

Strategie 2: CLOUD-ONLY

Kosten: ~$15-50/Monat
Best for: Keine GPU oder selten genutzt

PRIMARY: DeepSeek R1 via OpenRouter (~$5-10/Monat)
FALLBACK: GPT-5 (~$15/Monat)
OPTIONAL: Claude Sonnet 4.5 (~$25/Monat)

Strategie 3: LOCAL-ONLY

Kosten: $0 API + Strom (~€30-75/Monat)
Best for: 100% Privacy, GDPR-compliant

ONLY: gpt-oss-20b via Ollama (lokal auf GPU)

4.2 Setup: Hybrid-Strategie (Schritt-für-Schritt)

Schritt 1: Ollama + gpt-oss-20b installieren

# Ollama installieren
curl -fsSL https://ollama.com/install.sh | sh

# gpt-oss-20b herunterladen (~12GB, 5-15 Minuten)
ollama pull gpt-oss-20b

# Als Service starten
ollama serve &

# Testen
ollama run gpt-oss-20b "Erkläre Python decorators in 3 Sätzen"

# GPU-Nutzung prüfen
nvidia-smi
# Sollte ~14-15GB VRAM "Used" zeigen wenn Model aktiv

Performance-Zahlen:

  • RTX 5060 Ti 16GB: ~120-150 tokens/sec
  • RTX 4090 24GB: ~180-200 tokens/sec

Schritt 2: Cloud API-Keys holen

A) OpenAI GPT-5:

# Browser öffnen
firefox https://platform.openai.com/api-keys

# Schritte:
# 1. Einloggen/Registrieren
# 2. "+ Create new secret key"
# 3. Name: "Windsurf-HP-Z420"
# 4. Permissions: "All" (oder "Restricted" für mehr Control)
# 5. Key kopieren: sk-proj-XXXXXXXXXXXXXXXXXXXXXX
# 6. $10 Credits aufladen (Kreditkarte nötig)

B) Anthropic Claude (Optional):

# Browser öffnen
firefox https://console.anthropic.com/settings/keys

# Schritte:
# 1. Einloggen/Registrieren
# 2. "Create Key"
# 3. Name: "Windsurf-HP-Z420"
# 4. Key kopieren: sk-ant-XXXXXXXXXXXXXXXXXXXXXX
# 5. $10 Credits aufladen

C) DeepSeek (Budget-Option):

# Browser
firefox https://platform.deepseek.com

# Registrieren → API Keys → Create
# Kopierer: sk-XXXXXXXXXXXXXXXXXXXXXX

D) OpenRouter (Universal Gateway - Empfohlen!):

# Browser
firefox https://openrouter.ai

# Login → Settings → Keys → Create
# Free Tier: DeepSeek R1 kostenlos!
# Key: sk-or-v1-XXXXXXXXXXXXXXXXXXXXXX

Schritt 3: API-Keys sicher speichern

# Automatisches Setup-Script verwenden (EMPFOHLEN!)
cd ~/Downloads
wget https://raw.githubusercontent.com/your-repo/windsurf-api-setup.sh
chmod +x windsurf-api-setup.sh
./windsurf-api-setup.sh

# ODER: Manuelle Konfiguration
mkdir -p ~/.codeium/windsurf
nano ~/.codeium/windsurf/.env

.env Datei:

# OpenRouter (Universal Gateway)
OPENROUTER_API_KEY=sk-or-v1-xxxxxxxxxxxxxxxxxxxxx

# OpenAI GPT-5
OPENAI_API_KEY=sk-proj-xxxxxxxxxxxxxxxxxxxxx

# Anthropic Claude (optional)
ANTHROPIC_API_KEY=sk-ant-xxxxxxxxxxxxxxxxxxxxx

# DeepSeek (optional, günstiger als OpenRouter)
DEEPSEEK_API_KEY=sk-xxxxxxxxxxxxxxxxxxxxx

# X.AI Grok (Free in Windsurf!)
XAI_API_KEY=xai-xxxxxxxxxxxxxxxxxxxxx

# Ollama (Local)
OLLAMA_BASE_URL=http://localhost:11434

# Permissions setzen (wichtig!)
chmod 600 ~/.codeium/windsurf/.env

Schritt 4: MCP Server Config

nano ~/.codeium/windsurf/mcp_config.json

mcp_config.json (Hybrid Setup):

{
  "mcpServers": {
    "openrouter": {
      "command": "npx",
      "args": ["-y", "@openrouter/mcp-server"],
      "env": {
        "OPENROUTER_API_KEY": "${OPENROUTER_API_KEY}",
        "BASE_URL": "https://openrouter.ai/api/v1"
      }
    },
    "ollama-local": {
      "command": "curl",
      "args": ["-X", "GET", "http://localhost:11434/api/tags"],
      "env": {
        "OLLAMA_BASE_URL": "${OLLAMA_BASE_URL}"
      }
    }
  }
}

Schritt 5: Claude BYOK (optional, via Web-Interface)

# Browser öffnen
firefox https://windsurf.com/subscription/provider-api-keys

# Schritte:
# 1. Einloggen mit Windsurf-Account
# 2. "+ Add API Key"
# 3. Provider: "Anthropic"
# 4. API Key: sk-ant-XXXXXXXXXXXXXXXXXXXXXX (aus Schritt 2)
# 5. "Save" klicken
# 6. PyCharm neu laden (Strg+R oder Reload Window)

Nach BYOK-Setup verfügbar:

  • Claude 4 Sonnet (claude-sonnet-4-5-20250929)
  • Claude 4 Opus (claude-4-opus)
  • Claude 4 Sonnet (Thinking)
  • Claude 4 Opus (Thinking)

Schritt 6: PyCharm neu starten

# PyCharm beenden
pkill pycharm-community

# Neu starten
pycharm-community

# Oder: File → Reload Window (Strg+R)

Schritt 7: Model-Auswahl in Windsurf

In PyCharm:

  1. Cascade Chat öffnen (Strg+Shift+P → Windsurf)
  2. Oben im Chat: "Select Model" Dropdown
  3. Verfügbare Modelle sollten sein:
    • ✅ gpt-oss-20b (via Ollama) ← Primary!
    • ✅ GPT-5 (via OpenAI BYOK oder OpenRouter)
    • ✅ Claude Sonnet 4.5 (via BYOK)
    • ✅ DeepSeek R1 (via OpenRouter)
    • ✅ Grok (via OpenRouter oder XAI)
  4. Empfohlene Auswahl für Hybrid:
    • Default: gpt-oss-20b (90% Tasks)
    • Wechsel zu GPT-5 wenn: Frontend, Complex SWE-bench
    • Wechsel zu Claude wenn: Multi-File Refactoring, 30h+ Tasks

🧪 Teil 5: Funktionstest

5.1 PyCharm Refactoring testen

# Test-Projekt öffnen
cd ~/Development/ccc-code

# In PyCharm:
# 1. Öffne ccc/ccc/core/main.py
# 2. Rechtsklick auf Funktionsname (z.B. "main")
# 3. Refactor → Rename... (Shift+F6)
# 4. Neuer Name: "main_entry"
# 5. "Find Usages" Preview anschauen
# 6. Sollte ALLE 120+ Dateien durchsuchen!
# 7. Cancel (noch nicht committen)

✅ Erwartetes Verhalten:

  • PyCharm zeigt alle betroffenen Dateien im Preview
  • Imports werden automatisch angepasst
  • Keine False Positives bei ähnlichen Namen

5.2 Windsurf Cascade testen (gpt-oss-20b lokal)

Test 1: Code-Analyse (Primary Model)

1. Cascade Chat öffnen (Strg+Shift+P → Windsurf)
2. Model wählen: gpt-oss-20b
3. Prompt: "Analyze the architecture of this project. What are the main components?"
4. Warten... (sollte ~10-20 Sekunden dauern für erste Response)

Erwartetes Verhalten:

  • GPU-Nutzung steigt (nvidia-smi zeigt ~15GB VRAM)
  • Response nach 10-20 Sekunden
  • Cascade versteht Projekt-Struktur (wo/, ccw/, cca/, ccb/, ccc/)
  • Erkennt Cement Framework

Test 2: Frontend-Task (Fallback zu GPT-5)

1. Model wechseln: GPT-5
2. Prompt: "Create a modern login form with TailwindCSS"
3. GPT-5 sollte beste Aesthetic liefern

Test 3: Multi-File Refactoring (Fallback zu Claude)

1. Model wechseln: Claude Sonnet 4.5
2. Prompt: "Plan a safe refactoring to rename namespace 'wo' to 'ccc' across all files"
3. Claude sollte 30h Task-Plan erstellen

5.3 Performance-Vergleich

Benchmark: "Explain Python decorators"

# Lokal (gpt-oss-20b):
time ollama run gpt-oss-20b "Explain Python decorators"
# Erwartete Zeit: ~5-8 Sekunden (120-180 tok/sec)

# Cloud (GPT-5):
# Via Windsurf Chat
# Erwartete Zeit: ~2-4 Sekunden (Netzwerk + API)

# Cloud (Claude Sonnet 4.5):
# Via Windsurf Chat
# Erwartete Zeit: ~3-5 Sekunden

Kosten-Vergleich (1000 Prompts/Monat):

  • gpt-oss-20b: $0 API (nur Strom ~€30-75/Monat)
  • GPT-5: ~$15/Monat (bei moderater Nutzung)
  • Claude Sonnet 4.5: ~$25-35/Monat

5.4 Git-Integration testen

# In PyCharm Terminal (Alt+F12):
git status
git log --oneline -5

# Im Cascade Chat:
"Show me the last 5 commits and summarize the changes"

# Erwartetes Verhalten:
# - Cascade kann Terminal-Output lesen
# - Fasst Git-History zusammen
# - Erklärt Änderungen in natürlicher Sprache

💡 Teil 6: Best Practices für CCC CODE Projekt

6.1 Workflow für 120-Dateien-Refactoring

Phase 1: Planung (Claude-MAX via Browser)

1. Öffne https://claude.ai
2. Lade .context-chat.md + .context-project.md hoch
3. Erstelle strukturierten Arbeitsauftrag
4. Definiere klare Test-Kriterien

Phase 2: Sichere Änderungen (PyCharm Native)

1. PyCharm: Refactor → Rename (Shift+F6)
2. Preview ALLE 120+ Änderungen prüfen
3. Tests laufen lassen VORHER:
   cd ~/Development/ccc-code
   pytest tests/
4. Refactoring ausführen
5. Tests laufen lassen NACHHER:
   pytest tests/
6. Git Diff prüfen:
   git diff --stat

Phase 3: AI-Unterstützung (Windsurf Cascade)

1. gpt-oss-20b (lokal): "Review changes for potential issues"
2. GPT-5 (Cloud): "Check for edge cases in renamed functions"
3. Claude Sonnet 4.5 (Cloud): "Suggest comprehensive test cases"

Phase 4: Validierung (Aider via tmux)

1. tmux new-session -s refactor
2. aider --yes-always
3. Aider: "Run all tests and report failures"
4. Bei Erfolg: git commit -m "Refactor: Rename wo → ccc"

6.2 Model-Auswahl-Strategie

┌──────────────────────────────────────────────────────┐
│ USE CASE                    │ BEST MODEL            │
├──────────────────────────────────────────────────────┤
│ Code Review (90%)           │ gpt-oss-20b (Lokal)  │
│ Documentation               │ gpt-oss-20b (Lokal)  │
│ Unit Tests schreiben        │ gpt-oss-20b (Lokal)  │
│ Routine Refactoring         │ gpt-oss-20b (Lokal)  │
│ Quick Fixes                 │ gpt-oss-20b (Lokal)  │
├──────────────────────────────────────────────────────┤
│ Frontend/UI (8%)            │ GPT-5 (Cloud)        │
│ Complex SWE-bench Tasks     │ GPT-5 (Cloud)        │
│ Tool-Calling Heavy          │ GPT-5 (Cloud)        │
│ Performance-Critical        │ GPT-5 (Cloud)        │
├──────────────────────────────────────────────────────┤
│ Multi-File Refactoring (2%) │ Claude Sonnet 4.5    │
│ 30h+ Autonome Tasks         │ Claude Sonnet 4.5    │
│ Computer Automation         │ Claude Sonnet 4.5    │
│ Maximum Safety needed       │ Claude Sonnet 4.5    │
└──────────────────────────────────────────────────────┘

6.3 Sicherheits-Checkliste

☐ Backup gemacht (git commit BEFORE!)
☐ .context-chat.md & .context-project.md gelesen
☐ Preview ALLER Änderungen geprüft (PyCharm Refactor Preview)
☐ Tests laufen BEFORE Refactoring
☐ Refactoring in kleinen Schritten (max 20-30 Dateien/Schritt)
☐ Tests laufen AFTER jedem Schritt
☐ Git Diff gecheckt (git diff --stat)
☐ Nur bei 100% Success committen
☐ Cement Version beachtet (v2 vs v3!)
☐ NIEMALS wo/ Verzeichnis ändern! (Read-only!)

🚨 Teil 7: Troubleshooting

Problem 1: PyCharm startet nicht

Symptom: Icon funktioniert nicht oder Fehler beim Start

Lösung:

# PyCharm via Terminal starten (zeigt Fehler)
pycharm-community

# Java-Runtime prüfen (sollte mit PyCharm kommen)
dpkg -l | grep pycharm

# Falls nötig: Neuinstallation
sudo apt remove pycharm-community
sudo apt update
sudo apt install pycharm-community

# Python venv prüfen (häufiger Fehler)
sudo apt install python3-venv -y

Problem 2: Windsurf Plugin nicht gefunden

Symptom: "Windsurf" erscheint nicht im Marketplace

Lösung:

# 1. Internet-Verbindung prüfen
ping -c 3 plugins.jetbrains.com

# 2. PyCharm Proxy-Settings checken
# Settings → Appearance & Behavior → System Settings → HTTP Proxy

# 3. Alternative Suche: "Codeium" (alter Name)
# Marketplace → "Codeium" suchen

# 4. Cache löschen
rm -rf ~/.cache/JetBrains/PyCharmCE*
pycharm-community

Problem 3: gpt-oss-20b läuft nicht (GPU)

Symptom: "Error loading model" oder "Out of memory"

Lösung:

# GPU-Status prüfen
nvidia-smi

# Falls "NVIDIA-SMI has failed":
sudo apt install nvidia-driver nvidia-cuda-toolkit -y
sudo reboot

# Falls "Out of memory" (VRAM voll):
# Andere GPU-Prozesse finden
ps aux | grep -i cuda
kill <PID>

# ODER: Niedrigere Quantisierung laden
ollama pull gpt-oss-20b:q4_0  # 4-bit (braucht ~8GB statt 15GB)

# ODER: VRAM-Limit setzen
OLLAMA_NUM_GPU=1 OLLAMA_GPU_LAYERS=35 ollama serve

Problem 4: API-Keys funktionieren nicht

Symptom: "Unauthorized" oder "Invalid API Key"

Lösung:

# ENV-Vars prüfen
echo $OPENAI_API_KEY
echo $ANTHROPIC_API_KEY

# Falls leer: Neu laden
source ~/.bashrc

# .env-Datei prüfen
cat ~/.codeium/windsurf/.env

# Permissions prüfen
ls -l ~/.codeium/windsurf/.env
# Sollte: -rw------- (600) sein

# Test: Hardcode in mcp_config.json (temporär!)
# Wenn dann funktioniert → ENV-Loading-Problem

Problem 5: MCP Server offline (rot)

Symptom: MCP Server zeigt roten Status in Windsurf

Lösung:

# npx prüfen
which npx
# Sollte: /usr/bin/npx

# Falls nicht:
sudo apt install npm nodejs -y

# MCP Server manuell testen
npx -y @openrouter/mcp-server --version

# Logs prüfen
cat ~/.codeium/windsurf/mcp-server.log

# PyCharm neu starten
pkill pycharm-community
pycharm-community

Problem 6: Ollama Service läuft nicht

Symptom: gpt-oss-20b nicht erreichbar

Lösung:

# Service-Status prüfen
ps aux | grep ollama

# Falls nicht läuft: Manuell starten
ollama serve &

# Als systemd-Service einrichten (optional)
sudo tee /etc/systemd/system/ollama.service << EOF
[Unit]
Description=Ollama Service
After=network.target

[Service]
Type=simple
ExecStart=/usr/local/bin/ollama serve
Restart=always
User=$USER

[Install]
WantedBy=multi-user.target
EOF

sudo systemctl daemon-reload
sudo systemctl enable ollama
sudo systemctl start ollama

📊 Teil 8: Kosten-Kalkulation

Hardware: HP Z420 + RTX 5060 Ti 16GB

Stromverbrauch:

  • Idle: ~100W (CPU + MB)
  • GPU Full Load: ~200-250W (RTX 5060 Ti)
  • Total bei AI-Nutzung: ~350W

Strom-Kosten (Deutschland, ~0,30€/kWh):

Szenario 1: 8h/Tag Nutzung
→ 8h × 350W = 2,8 kWh/Tag
→ 2,8 × 0,30€ = 0,84€/Tag
→ 30 Tage = ~25€/Monat

Szenario 2: 24/7 Betrieb
→ 24h × 350W = 8,4 kWh/Tag
→ 8,4 × 0,30€ = 2,52€/Tag
→ 30 Tage = ~75€/Monat

Kosten-Vergleich (Real-World, 50 Requests/Tag)

┌────────────────────────────────────────────────────┐
│ SETUP          │ API-Kosten  │ Strom   │ TOTAL    │
├────────────────────────────────────────────────────┤
│ LOCAL-ONLY     │ \$0          │ €25-75  │ €25-75   │
│ HYBRID         │ \$20         │ €25-75  │ €45-95   │
│ CLOUD-ONLY     │ \$20-50      │ €0      │ €20-50   │
│ FREE           │ \$0          │ €0      │ €0! 🎉   │
└────────────────────────────────────────────────────┘

Fazit:

  • <€50/Monat Nutzung: Cloud-Only ist günstiger!
  • >€50/Monat Nutzung: Hybrid lohnt sich (Privacy + Kosten)
  • Privacy-Critical: Local-Only trotz höherer Kosten

🎯 Teil 9: Optimales Setup für dich (HP Z420)

Empfehlung: HYBRID-Strategie

Warum?

  • ✅ 128GB RAM → Perfekt für große Projekte (CCC CODE)
  • ✅ RTX 5060 Ti 16GB → Perfekt für gpt-oss-20b
  • ✅ Xeon E5-2697 v2 (12C/24T) → Gut für Compile-Tasks
  • ✅ Balance: Privacy (90%) + Cloud-Power (10%)

Setup in 30 Minuten:

# 1. PyCharm installieren (5 min)
sudo apt install pycharm-community -y

# 2. Windsurf Plugin (2 min)
# In PyCharm: Settings → Plugins → "Windsurf" → Install

# 3. Ollama + gpt-oss-20b (15 min)
curl -fsSL https://ollama.com/install.sh | sh
ollama pull gpt-oss-20b

# 4. API-Keys Setup (5 min)
wget https://raw.githubusercontent.com/your-repo/windsurf-api-setup.sh
chmod +x windsurf-api-setup.sh
./windsurf-api-setup.sh

# 5. Claude BYOK (3 min)
firefox https://windsurf.com/subscription/provider-api-keys

# ✅ FERTIG! Full AI Coding Stack

Was du bekommst:

PRIMARY (90%): gpt-oss-20b (lokal, \$0 API, 120-180 tok/sec)
FALLBACK (8%): GPT-5 (Cloud, \$15/Monat, SWE-bench King)
FALLBACK (2%): Claude Sonnet 4.5 (Cloud, \$5/Monat, 30h Tasks)

TOTAL: ~\$20/Monat + €25-75 Strom
CAPABILITY: Frontier-Level AI Coding!

Dokumentation

  • PyCharm Docs: https://www.jetbrains.com/help/pycharm/
  • Windsurf Docs: https://docs.windsurf.com/
  • Ollama Docs: https://github.com/ollama/ollama
  • gpt-oss GitHub: https://github.com/openai/gpt-oss

Community & Support

  • PyCharm Forum: https://intellij-support.jetbrains.com/hc/en-us/community/topics/200366979
  • Windsurf Discord: https://discord.gg/windsurf
  • Ollama Discord: https://discord.gg/ollama
  • LocalLLaMA Reddit: https://reddit.com/r/LocalLLaMA

CCC CODE Projekt

  • GitHub: https://github.com/collective-context/ccc-code
  • Docs: https://collective-context.org/
  • Whitepaper: https://recode.at/collective-context-cc-whitepaper/

API-Dokumentation

  • OpenRouter: https://openrouter.ai/docs
  • OpenAI: https://platform.openai.com/docs
  • Anthropic: https://docs.anthropic.com/
  • DeepSeek: https://platform.deepseek.com/docs

🎓 Teil 11: Nächste Schritte

Sofort (heute):

  1. ✅ System vorbereiten (Teil 1)
  2. ✅ PyCharm via APT installieren (Teil 2)
  3. ✅ Windsurf Plugin installieren (Teil 3)
  4. ✅ API-Setup wählen & durchführen (Teil 4)
  5. ✅ Funktionstest (Teil 5)

Diese Woche:

  1. 📚 PyCharm Shortcuts lernen (Shift+F6, Strg+Alt+L, etc.)
  2. 🧪 Alle drei Models testen (gpt-oss-20b, GPT-5, Claude)
  3. 🎯 Model-Auswahl-Strategie für CCC CODE festlegen
  4. 📝 Workflow mit Aider integrieren

Diesen Monat:

  1. 🚀 120-Dateien-Refactoring starten!
  2. 📊 API-Kosten monitoren (welches Model am meisten?)
  3. 🤖 Optimierungen: GPU-Tuning, Model-Quantisierung
  4. 🎯 Lessons Learned dokumentieren

🏆 Fazit

Du hast jetzt das ULTIMATIVE Setup für AI-Coding (Oktober 2025):

✅ PyCharm Community (APT): Beste Refactoring-Tools, native Debian
✅ Windsurf Plugin: Cascade AI, MCP Server Support
✅ gpt-oss-20b (Lokal): 90% Tasks, $0 API, 100% Privacy
✅ GPT-5 (Cloud): 8% Complex Tasks, SWE-bench King (74.9%)
✅ Claude Sonnet 4.5 (Cloud): 2% Ultra-Tasks, 30h Autonomie
✅ HP Z420 Power: 128GB RAM, RTX 5060 Ti optimal genutzt
✅ Kosten: ~$20/Monat + Strom (beste Balance!)

Für dein CCC CODE Projekt (120-Dateien-Refactoring):

  • ✅ Sichere Namespace-Änderungen mit PyCharm Safe Rename
  • ✅ AI-Unterstützung mit 3-Tier Model-Strategie
  • ✅ Terminal-Integration für Aider-Workflow
  • ✅ Privacy-First mit lokal laufendem gpt-oss-20b

Die Golden Age of AI Coding ist JETZT! 🚀

Erstellt für: HP Z420 Workstation (Xeon E5-2697 v2, 128GB RAM, RTX 5060 Ti 16GB)
OS: Debian 12 Bookworm / Debian 13 Trixie
Letzte Aktualisierung: Oktober 2025
Version: 2.0 (mit gpt-oss-20b Hybrid-Setup)
Projekt: Collective Context Commander (HUFi.AI)

Previous

VSCodium + Continue.dev