KI Coding Plugin

Language:	Deutsch  • English

KI Coding Plugin

Die hier beschriebenen KI-Funktionen sind Teil des Lizenz-Features AI Coding. Ist dieses Feature in Ihrer Lizenz nicht enthalten, erscheinen die Ask AI-Menüeinträge zwar weiterhin sichtbar in den Editor-Toolbars, sind aber deaktiviert (Tooltip: "Install the AI coding plugin to enable").

Das KI Coding Plugin bindet einen Large Language Model (LLM) basierten KI-Assistenten in den Activity-Editor (Aktivitäten-Code), den Compound-Netzwerk-Editor, den Dokumentations-Editor und in den ST/X Class Browser ein. Das Plugin unterstützt mehrere Anbieter, die im Einstellungsdialog umschaltbar sind:

• Anthropic (aka Claude) (claude-opus-4-7, claude-sonnet-4-6, claude-haiku-4-5)
• OpenAI (i.e. ChatGPT) (gpt-4o, gpt-4o-mini, gpt-4.1, gpt-4.1-mini, gpt-4.1-nano, o1, o3)
• Ollama lokal oder remote (codellama:7b, codellama:13b)
• llama.cpp lokal oder remote
• Groq, Zen, LLaMa, Tabnine etc.
• Claude Code (subscription) — nutzt Ihr vorhandenes Claude-Abonnement statt eines API-Schlüssels (verfügbar ab expecco 26.2)
• Inhouse — ihre eigene in-house (in-Firma) KI.

Wichtig:
Der zusätzliche Eintrag Inhouse ist für eigene, firmeninterne KI vorgesehen.

Anm.: tatsächlich sprechen all hinterher das selbe Protokoll; sie können also auch unter irgend einem anderen Anbieter einfach die URL zu ihrer eignene KI eingeben. Dieser Eintrag dient also lediglich der Übersichtlichkeit, und einem Platz wo Sie Ihre Zugangsdaten ablegen können, wenn Sie doch noch zwischen durch mit anderen Anbietern oder einer anderen fimeninternen KI chatten können und wollen ohne jedesmal die URLs und API keys neu eingeben zu müssen.

Je nach gewähltem Anbieter erscheint die Toolbar-Schaltfläche als Ask Claude bzw. Ask ChatGPT bzw. Ask ... ; das Einstellungs-Tab heißt "AI Coding", unter Plugins (Erweiterungen).

Architektur und Sicherheit

Im folgenden werden die Einstellungen und die zugehörigen Datenflüsse/kanäle beschrieben.

Mit "Sicherheit" ist hier gemeint: "können die Daten den Rechner oder ihre Abteilung/Firma verlassen bzw. kann die KI Schaden anrichten".

Anmerkung: Wenn hohe Sicherheit gefordert ist (sensible Daten, Algorithmen, Workflows) muss Ihr Netzadmin durch geeignete Maßnahmen (Firewall, Router/Switch Konfiguration etc.) verhindern, dass Zugriffe sowohl ausgehend als auch eingehend zu/von außerhalb ihrer Domäne möglich sind. Das "unsichtbar machen" entsprechender Einstellungsdialoge in expecco wäre hierzu nicht dienlich, da bei offenen Ports unzählige andere Möglichkeiten bestehen (curl, webbrowser, low-level Socket API etc.).

Zur Sicherheit ihrer eigenen Testsuite lesen Sie bitte die unten aufgeführten Abschnitte zu Tool use.

Mögliche Setups sind:

KI Firmenintern

• direkte Verbindung zu einer KI auf einem Rechner in ihrem lokalen Netzwerk, Firmennetz oder einem definiert sicheren Firmenanbieter.
  Sicherheit: Hoch (weder Daten noch Chat-Text gehen aus dem Haus)

• 
  Einstellung
• 
  Architektur

expecco kommuniziert ausschließlich und direkt zu dieser URL; keine Applikation dazwischen. Insbesondere kein "claude.exe" oder ein anderes Command Line Interface (CLI) Programm. Ihre Eingaben im expecco Chat Fenster gehen direkt (verpackt als JSON) an die konfigurierte Adresse und deren Antwort erscheint (entpackt aus JSON) im expecco Chat Fenster. Nachrichten werden ausschließlich mit dem von Ihnen konfigurierten Host ausgetauscht.

- wählen Sie dazu "inhouse" und geben hostname+port+URL zu diesem host ein; typischerweise haben diese die Form "firmenAI:11434/v1/chat/completions" oder auch 80 oder 8080 als port. Fragen Sie ihren Netzwerkadmin im Zweifel, auch ob ein API Key (= Zugangsschlüssel) erforderlich ist.

KI auf Ihrem eigenen Rechner

• direkte Verbindung zu einer lokalen KI auf ihrem eignen persönlichen Rechner
  Sicherheit: Sehr Hoch (weder Daten noch Chat verlassen ihren Rechner)

• 
  Einstellung
• 
  Architektur

auch hier kommuniziert expecco ausschließlich und direkt zu diesem ihrem lokalen Rechner, auf der Sie selbst ein Modell installiert und am Laufen haben (ollama oder llama.cpp). Ob dies im einzelnen sinnvoll ist hängt von der Leistungsfähigkeit ihres eigenen Rechners ab (empfohlen wird eine oder mehrere leistungsfähige GPUs mit viel VRAM (>=32Gb), großer RAM Speicherausbau (>=64Gb) und ein leistungsfähiges Modell (mindestens 30B, besser 120B mit großem Kontext,da reichen aber 32GB VRAM nicht); eigene Erfahrungen haben wir unten in diesem Dokument zusammengetragen).

- wählen Sie dazu "ollama" oder "llama.cpp" und geben als hostname "localhost" ein.

KI von einem Cloudanbieter

• direkte Verbindung zu einem externen Anbieter (wie Anthropic, OpenAI etc.).
  Sicherheit: Fragwürdig (falls Sie dem Anbieter vertrauen)

• Einstellung
  Einstellung
• Architektur
  Architektur

Die Interaktion erfolgt lediglich mit der von Ihnen eingestellten URL über das expecco-interne chat Fenster. In sicherheitskritischem Umfeld ist jedoch davon abzuraten und ihre Netzadministrator wird diesen Zugang vermutlich auch nicht zulassen da (je nach URL ihre Daten und ihr Chatverlauf an externe Rechner gehen, oder von fremden Geheimdiensten mitgelesen werden könnten). Prinzipiell sollte dies dem Netzadmin aber bekannt sein,und auf Netzwerkebene gesperrt sein, da ein solcher Zugriff auch anderen Programmen verwehrt werden muss (curl oder dem Webbrowser). Insofern ist ratsam, diese Verbindung auf administrativer Ebene (Firewall, Router/Switch Konfiguration etc.) zu verhindern. Natürlich gilt dies nicht, falls sie eine eigenen frmeninterne cloud Infrastruktur besitzen, die vertrauenswürdig ist.

- wählen Sie dazu "Anthropic, OpenAI, ..." und geben hostname+port+URL zu diesem host ein (wobei die Vorgabe im Eingabefeld typischerweise schon passt); typischerweise brauchen die Anbieter einen Zugangsschlüssel (sog. API key), den Sie bei der Registrierung vom Anbieter oder von ihrem Netzadmin erhalten. Achtung: vershciedene Anbieter (u.a. Anthropic) erlauben hier nur die Abrechnung über Ihr Token Budget, nicht über einen Pro/Max oder Enterprise plan. Es kann also hier zu erhöhten Kosten führen. Esist uns weder technischnch juristisch möglich, dies zu verhindern.

KI über CLI (eg. claude code); Bedienung über CLI

• indirekte Verbindung via CLI (z.B. ClaudeCode, Kiro, Tabnine, OpenCode, LMStudio etc.).
  Sicherheit: Fragwürdig (falls Sie dem Anbieter vertrauen)

• Einstellung
  Einstellung
• Architektur
  Architektur

Hier baut ein CLI Programm (z.B. "claude.exe") die Verbindung zum KI Modell auf (was natürlich seinerseits wiederum eine lokale in-house KI sein könnte). Dieses CLI Programm verbindet sich dann mit expecco und hat dort beschränkten Zugriff auf ihre Testsuite. Die Interaktion erfolgt mit dem CLI Programm, die Interaktion mit dem Modell erfolgt darin, wobei es kontrolliert Zugriff auf expecco erhält (über das sog. MCP Protokoll).

- sie müssen dem lokalen CLI Programm den Zugriff auf expecco erlauben. gehen Sie dazu in das "Extras" → "Web-Dienste" → "MCP Zugriff erlauben (AI Coding)".
Die Konfiguration zum eigentlichen Modell erfolgt im CLI Programm Ihrer Wahl und ist nicht unter der Kontrolle von expecco; expecco erlaubt damit lediglich die Kontrolle von außerhalb über das MCP Protokoll. Eine Einstellung des Anbieters ist nicht notwendig; sie wird nicht benutzt, können daher beliebige Angaben machen.

KI über transparente CLI (nur claude code); Bedienung über ChatView

• indirekte Verbindung via unsichtbarer ClaudeCode CLI.

Sicherheit: Fragwürdig (falls Sie dem Anbieter vertrauen)

• Einstellung
  Einstellung
• Architektur
  Architektur

Auch hier erfolgt die Verbindung über das ClaudeCode CLI Programm, welches jedoch ohne Benutzeroberfläche den Verkehr lediglich weiter leitet (via stdin/stdout). Die Benutzerinteraktion erfolgt über das expecco-interne chat Fenster, der tatsächliche Modellzugriff vom CLI. Auch hier muss die Konfiguration des Modellzugriffs im CLI Programm erfolgen.

Aktivitäten-Editor

Im Aktivitäten-Code-Editor erscheint in der Toolbar eine Schaltfläche Ask Claude / Ask ChatGPT mit folgenden Aktionen:

• Open KI Chat Window — öffnet das eigenständige Chat-Fenster
• Explain code — erklärt den Code der aktuellen Aktivität
• Suggest improvement — schlägt Verbesserungen vor
• Find bugs — sucht nach Fehlern, Race Conditions, nil-Handling-Problemen
• Generate doc-comment — generiert eine Aktivitäts-Dokumentation inklusive Pin-Kommentaren und füllt den Documentation-Tab
• Custom prompt... — freier Prompt; der Aktivitäts-Code wird als Kontext mitgesendet
• Set model ▸ — Untermenü mit den Modellen des aktiven Anbieters (das aktuell aktive Modell ist mit (active) markiert)
• Set provider ▸ — nur sichtbar, wenn API-Schlüssel für mehr als einen Anbieter konfiguriert sind; Untermenü zum Umschalten zwischen Claude, ChatGPT oder anderem Anbieter

Code-Vorschläge können mit [Apply] (direkt am jeweiligen Code-Block im Chat oder über die obere Apply-Schaltfläche) in den Aktivitäts-Body übernommen werden. Vom KI gelieferte Smalltalk/X Hilfsmethoden (Form: Klasse >> selector) werden nach Rückfrage in die genannte Klasse compiliert.

Compound (Netzwerk) Editor

Auf der Toolbar von Compound-Worksheets erscheint dieselbe Schaltfläche, beschränkt auf die für Netze sinnvollen Aktionen (Open KI Window, Generate doc-comment) — ebenfalls mit den Untermenüs Set model und ggf. Set provider.

Dokumentations-Editor

Der Dokumentations-Tab der Block-Description (Editor für Test-Cases, Test-Plans und Aktivitäten) trägt dieselbe Toolbar-Schaltfläche Ask ... mit den obigen Einträgen Generate doc-comment analysiert den aktuellen Block (Name, vorhandene Beschreibung, Eingangs-/Ausgangs-Pins, Sub-Steps eines Compound-Netzes, referenzierte Environment-Variablen) und schlägt eine vollständige Block- und Pin-Dokumentation vor.

Ist der Block schreibgeschützt (importierte Library, RTL-Lizenz), fragt [Apply] nach, ob der Block freigeschaltet und die Dokumentation eingetragen werden soll.

Class Browser (ST/X)

Im Class Browser stehen die Aktionen unter dem AI-Untermenü sowie im Selektor-Kontextmenü zur Verfügung. Die Aktionen operieren auf der aktuell ausgewählten Methode (Klasse + Selektor + Quelltext werden als Kontext mitgesendet). [Apply] kann das Resultat direkt in die Methode der aktiven Klasse einbauen. Auch hier sind Set model und ggf. Set provider als Untermenüs verfügbar.

Zusätzlich gibt es zwei Aktionen, die sich auf die ausgewählte Klasse beziehen statt auf eine einzelne Methode (verfügbar ab expecco 26.2). Es genügt, die Klasse auszuwählen; eine Methodenauswahl ist dafür nicht nötig:

• Explain Class — erklärt die Klasse als Ganzes: wofür sie zuständig ist, welche Rolle ihre Instanzvariablen spielen, wie ihre Protokolle zusammenwirken und worauf man beim Verwenden achten muss.
• Generate Class Documentation — schlägt einen Dokumentationstext für die Klasse vor; [Apply] trägt diesen in die Dokumentation der Klasse ein.

Chat-Fenster

Das eigenständige Chat-Fenster trägt den Titel AI Coding [<Produkt> / <Modell>] (z.B. "AI Coding [Claude / claude-opus-4-7]") und zeigt nach jedem Turn den Tokenverbrauch und die kumulierten Kosten — sofern Preise für das gewählte Modell hinterlegt sind. Anbieter- und Modellwechsel im Einstellungsdialog werden live übernommen.

Das Transkript ist als vertikales Panel von "Karten" aufgebaut:

• Prosa-Karten enthalten den fließenden Text der Antwort; Zeilen werden auf die Fenster-Breite umgebrochen.
• Code-Karten (eingerahmt) entstehen aus markdown-Code-Blöcken (```...```) und sind als Workspace editierbar — das Standard-Smalltalk-Popup-Menü bietet doIt / printIt / inspectIt, ein TestCase-simulatedSelf ist gesetzt, so dass self assert:... equals:... direkt ausgeführt werden kann. Lange Blöcke scrollen innerhalb der Karte. Rechts oben sitzen die Schaltflächen [Apply] (sofern für den Kontext sinnvoll) und [⎘ Copy]; links wird der Sprachtag (smalltalk, python, …) angezeigt.
• Doku-Karten (volle Breite, Prosa) entstehen aus dem speziellen ```doc-Block, den der Dokumentations-Generator anfordert; Inhalt ist die Vorschlags-Dokumentation für Block- und Pin-Beschreibungen.

Scroll-Lock: solange der Anwender bereits am unteren Ende des Transkripts steht, folgt die Anzeige neu eintreffenden Karten automatisch; nach manuellem Hochscrollen bleibt die Position stehen.

Bilder können als Anhang versendet werden (Screenshot oder PNG/JPG-Datei). Anhänge funktionieren nur mit vision-fähigen Modellen (bei OpenAI z.B. gpt-4o-Familie).

Einstellungen (AI Coding)

Im Einstellungsdialog unter Plugins → AI Coding (bzw. unter Tools → AI Coding im Smalltalk-Launcher) werden konfiguriert:

• Provider — Anthropic, OpenAI etc. Beim Wechsel werden API-URL und Default-Modell entsprechend angepasst; der gespeicherte API-Schlüssel des jeweiligen Anbieters wird geladen.

• Claude Code (subscription) (verfügbar ab expecco 26.2) — dieser Anbieter verwendet nicht die API, sondern das lokal installierte Kommandozeilenprogramm Claude Code und damit Ihr vorhandenes Claude-Abonnement. Es wird kein API-Schlüssel benötigt, und es fallen keine tokenbasierten API-Kosten an. Die Felder API Key, API URL und Proxy werden für diesen Anbieter ausgeblendet, da sie hier keine Bedeutung haben; als Authentifizierung erscheint "Subscription (external login)". Voraussetzung ist, dass Claude Code installiert ist und einmalig angemeldet wurde — dazu claude in einer Konsole starten und die Anmeldung abschließen. Das Modell kann als Stufen-Alias (sonnet, opus, haiku — jeweils das aktuelle Modell dieser Stufe) oder als fester Modellname angegeben werden.

• API Key — Schlüssel des aktuell gewählten Anbieters. Die Schlüssel werden pro Anbieter getrennt gespeichert (#claudeApiKey_anthropic bzw. #claudeApiKey_openai), so dass zwischen den Anbietern ohne erneute Eingabe gewechselt werden kann. Das Setzen des Schlüssels erfolgt ausschließlich über diesen Dialog.

• Model — ein Modell aus der Liste des aktiven Anbieters oder ein selbst eingegebener Modellname. Kann auch direkt über das Set model-Untermenü in den Editor-Toolbars umgeschaltet werden.

• Max output tokens — maximale Antwortlänge.

• API URL — nur zu ändern für eigene Proxies / Gateways. Standard: https://api.anthropic.com/v1/messages bzw. https://api.openai.com/v1/chat/completions.

API-Schlüssel beschaffen

• Anthropic: console.anthropic.com, Schlüsselformat sk-ant-....
• OpenAI: platform.openai.com/api-keys, Schlüsselformat sk-... oder sk-proj-.... Voraussetzung ist ein aufgeladenes Konto (Mindestbetrag derzeit USD 5).

Datenschutz / Datenfluss

Bei aktivem Anbieter Anthropic gehen die Anfragen direkt an api.anthropic.com, bei OpenAI direkt an api.openai.com. Es gibt keinen eXept-seitigen Proxy oder Zwischenspeicher. Mit dem Aktivitäts-Quelltext bzw. den Methoden- Quelltexten werden auch Pin-Beschreibungen, Sub-Step-Namen und referenzierte Environment-Variablen aus dem Block-Description-Modell als Kontext versendet.

Bei Benutzung von Anthropic API-Tokens - wie hier der Fall - werden laut Anthropic die Daten nicht zum Training des KI-Modells genutzt (Anthropic Erkärung dazu).
Für die Wahrheit dieser Aussage können wir nicht garantieren und haften.
Zu bedenken ist auch, daß die KI-Modelle nicht in inländischen Rechenzentren laufen, und eventuell weitere "Mitleser" involviert sind. Dies gilt insbesondere für Hightech, KI, Software und Defence Unternehmen, wo Fälle von Wirtschaftsspionage bekannt sind.

⚠ Wenn Sie sicher sein wollen, daß keine Information Ihr Haus verlässt empfehlen wir eine eigenem geschlossene in-House KI Umgebung, wie sie bei einigen unserer Kunden bereits existiert. Sie dürfen dann selbstverständlich nur die URLs dieser Umgebung konfigurieren. Expecco kommuniziert ausschließlich mit der von Ihnen eingegebenen KI.

Coding Assistenten

Beim Start der MCP-Server-Anbindung trägt expecco die nötigen Konfigurationseinträge automatisch in die Config-Dateien der unterstützten Coding-Assistenten ein. Die folgenden Abschnitte beschreiben Ort und Format der jeweiligen Einträge — zur Information bzw. falls Sie sie manuell ergänzen oder kontrollieren möchten.

Claude Code

Anm.: Dieser Abschnitt beschreibt den umgekehrten Weg — ein extern laufendes Claude Code greift auf expecco zu. Wenn Sie Claude Code umgekehrt als KI-Anbieter innerhalb von expecco nutzen möchten, siehe den Anbieter Claude Code (subscription) im Abschnitt Einstellungen (ab expecco 26.2).

Einträge für den mcp-server werden von expecco in die ".claude.json Datei (typischerweise in Ihrem Homeverzeichnis) vom Einstellungsdialog eingebracht:

 ...
 "mcpServers": {
   "mcp": {
     "type": "http",
     "url": "http://127.0.0.1:9876/mcp"
   },
 },
 ...

danach sollte nach dem Start von "claude.exe" diese mit dem /mcp Kommando gelistet werden.

Opencode (mit Zen)

Nach der Anmeldung (opencode authlogin) starten Sie opencode erneut. Aktuell müssen die mcp in einem Editor von Ihnen konfiguriert werden (autom. Eintrage in einer späteren Version. Ändern Sie dazu die Datei ".config\opencode\opencode.jsonc" (ebenfalls im typischerweise Heimatverzeichnis) zu:

{
 "$schema": "https://opencode.ai/config.json",
 "mcp": {
   "mcp": {
     "type": "remote",
     "url": "http://127.0.0.1:9876/mcp"
   },
 }
}

Sollten Sie ein Komma vergessen haben wird beim Start eine Fehlermeldung erscheinen. Mit "/mcps" sollten die beiden aufgelistet werden.

Cursor

Cursor liest seine MCP-Konfiguration aus ~/.cursor/mcp.json (Windows: %USERPROFILE%\.cursor\mcp.json). Ergänzen Sie dort:

{
  "mcpServers": {
    "mcp": {
      "url": "http://127.0.0.1:9876/mcp"
    },
  }
}

Beim nächsten Start von Cursor sollten die Server unter Settings → MCP als connected erscheinen.

Zed

Zed liest seine MCP-Konfiguration aus ~/.config/zed/settings.json (Windows: %APPDATA%\Zed\settings.json). Der Eintrag steht unter dem Schlüssel context_servers (nicht mcpServers wie bei den anderen):

{
  "context_servers": {
    "mcp": {
      "url": "http://127.0.0.1:9876/mcp"
    },
  }
}

Tabnine

Tabnine sucht seine MCP-Konfiguration zuerst projektbezogen unter <Projekt>/.tabnine/mcp_servers.json, dann im Homeverzeichnis (~/.tabnine/mcp_servers.json, Windows: %USERPROFILE%\.tabnine\mcp_servers.json):

{
  "mcpServers": {
    "mcp": {
      "url": "http://127.0.0.1:9876/mcp"
    },
  }
}

Alternativ können Sie den Server auch direkt im Tabnine-IDE-Plugin über ☰ → ⛭ Settings → Tools and MCPs → MCP servers → + Add MCP server eintragen.

Tipps

• Mehrere Konversationen: der Chat ist ein Singleton — eine neue Anfrage über ein Browser-/Editor-Menü startet jedesmal eine neue Konversation. Folge-Fragen (Klärung, Vertiefung) gehen über das Eingabefeld in derselben Konversation.
• Vorsicht: Die Größe der übertragenen Daten (auch die aus dem Chatfenster) geht in die Kostenberechnung ein. Deshalb immer eine neue Konversation starten, wenn es um ein neues Thema geht.
• Modell wechseln: Für schnelle Routine-Antworten Haiku oder Sonnet, für schwierige Refactorings Opus. Über das Set model-Untermenü direkt aus der Toolbar oder über die Settings.
• Anbieter wechseln: Sind Schlüssel für beide Anbieter konfiguriert, schaltet das Set provider-Untermenü ohne Umweg über den Settings-Dialog um.
• Code direkt ausführen: In Code-Karten kann markierter Smalltalk-Code per doIt / printIt / inspectIt direkt evaluiert werden — praktisch z.B. um vom Modell vorgeschlagene SUnit-Asserts gleich auszuprobieren, ohne den Code erst in einen Workspace zu kopieren.
• Custom prompt eignet sich gut für „warum macht Methode X es so und nicht so?" oder „schreib mir einen ParameterizedTest dazu mit folgenden Daten: …".

Tipps für die Arbeit mit claudeCode

Dieser Abschnitt ist veraltet; die unten aufgeführten Aufgaben könnnen nun 1:1 auch so im Chatfenster ausgeführt werden.

Wenn Sie ClaudeCode oder Opencode verwenden, stehen ihnen noch weit mehr Funktionen zur Verfügung: sie können zum Beispiel im claudeCode Terminal eingeben:

• "mach mir eine neue Suite in einem neuen Fenster",
• "Mache eine Aktion zur Berechnung des Umfangs eines Kreises bei gegebenen Radius",
• "Erstelle eine neue Suite mit einem Testfall der folgendes macht:
  • 1) webbrowser auf "www.exept.de" öffnen.
  • 2) auf das logo oben links klicken.
  • 3) webbrowser schliessen.
• welche Funktionalität ist in xxx.ets

(Anm.: es spielt keine Rolle, ob Sie sich in Deutsch oder Englisch unterhalten)

Claude wurde von uns in die Lage versetzt, selbst nach passenden Bibliotheken zu suchen, diese zu importieren, Aktionen zu generieren und den Testplan anzulegen.

Tatsächlich auch, den Test gleich durchzuführen und das Resultat zu analysieren.

Aktuell sind wir am trainieren, so dass claude z.B. selbst entscheidet ob es besser ist, eine fehlende Aktion als Diagramm oder elementa zu definieren. Es ist in der Lage, die Funktionen des unterliegenden Frameworks zu sehen und auch komplexe Aufgaben zu erledigen:

• "Aktion zum Lesen der Jahresumsätze eines Jahres aus der Datenbank"
• extrahiere aus dem xml Dokument alle budget Einträge und liefere die Summe

Erfahrungen und Tipps für die Arbeit

Modellwahl; Sonnet, Heiku und Fable

Sonnet-4 ist gefühlt weit intelligenter als Heiku-4.5, aber auch weit teurer. Fable ist für sehr komplexe Aufgaben, aber sehr teuer (ich meine: wirklich teuer). Ihr Budget kann sehr schnell schmelzen mit Sonnet - insbesondere wenn man auf medium oder high Intelligenzlevel arbeitet. Haiku macht weit mehr Fehler und man sollte genau hinschauen was er so generiert. Gefühlt war Sonnet selbst im low level besser als Haiku. Aber der Preis... Noch besser ist Fable, aber extrem teuer; in einer halben Stunde kann da schon mal das Tagesbudget an Tokens verbraucht werden.

Folgende konkrete Tipps aus unseren ersten Erfahrungen, diese Liste wird aktualisiert, und kann auch basieren auf unserer eigenen Dummheit. Ist also u.U. mit Vorsicht zu genießen.

• geben Sie Haiku mehr Hinweise, z.B. "schau mal dort, oder nimm das als Beispiel". Sonnet findet selbst viel besser Lösungen.

• kurze Anweisungen, je konkreter desto günstiger.

• Haiku ist weit "fauler". Z.B hat sonnet automatisch eine Dokumentation bei neuen Aktionen angelegt, und diese auch aktualisiert. Haiku hingegen musste man explizit eine Regel dazu anlegen (z.B. mit "wenn du eine Aktion anlegst oder änderst, aktualisiere die Dokumentation")

• Heiku ist dümmer. Regeln die von Sonnet angelegt wurden, können von Haiku u.U. nicht befolgt werden, weil Sonnet weit mehr generalisieren kann.

• sagen Sie allen sie sollten wenn sie ein Problem haben, nicht lange selbst suchen. sondern nachfragen ob man ihnen einen Tipp geben kann. Wenn Sie das nicht tun, kann es sein dass Sonnet auch eine viertel Stunde nachdenkt und die Dollars schmelzen wie Eis in der Sonne
  (ist mir passiert, als ein Socket Problem in der Kommunikation auftrat, und er nicht erkannte, das die Antworten von mcp falsch waren, es hat dann selbst alle möglichen Wege gesucht, eine Nachricht abzusetzen, incl. der Erstellung diverser Shell, curl und Python Scripte... obgleich es eigentlich ein Interface dafür gab, das aber einen Fehler hatte). Insbesondere hatte ich dummerweise vorher sinngemäß gesagt er solle, wenn ein Problem auftritt dies und jenes tun, wobei dabei genau dieses Problem wieder auftrat...

• schränken Sie das Modell in seinen Möglichkeiten ein, z.B. sagen sie "editiere nicht die files sondern verwende dazu ein tool", oder "eine expecco Aktion und sag mir vorher welche du nimmst". Sonst kann es passieren dass es anfängt ihre ets zu entpacken um darin nach Strings zu suchen, obgleich es das eigentlich einfacher über das interface machen kann (dieses konkrete Problem wird nicht mehr auftreten aber Sie sehen den Punkt). Da war Sonnet weit intelligenter hat aber auch länger nachgedacht.

• wenn sie feststellen, dass es einen Fehler macht, sagen sie (mehr oder weniger wörtlich) "remember: mach dies nicht, oder um das zu machen tu das."

• sie können diese Erinnerungen sowohl in ihrem UserProfile (also im lokalen Filesystem) als auch in ihren expecco Präferenzen halten. Sagen Sie dazu "remember this in in my expecco preferences" oder "remember (in my user memory): bla bla". Erinnerungen kann man auch löschen "forget to ...". Zu Beginn der nächsten Session sagen sie "read the expecco preferences memory".

• wechseln sie das Modell oder den level, je nach Komplexität der Aufgabe. Aber bedenken Sie dass Wissen von Session zu Session verloren geht, wenn es nicht erinnert wird. Technisch sind Erinnerungen nichts anderes als das Lesen einer Liste der vormaligen remember Anweisungen. Kosten also auch Tokens. Sie könnten also die Erinnerungen auch einfach neu eintippen ;-)

• Fable ist ein echter Star, wenn es darum geht, z.B. eine komplexe Architektur zu entwerfen. Mein Tipp: lassen sie ihn einen Plan machen, und von einem einfacheren Modell Schritt für Schritt umsetzen.

• auch wenn es so scheint: das "Ding" ist kein Mensch; lassen sie "bitte, danke, oder Begründungen - es sei denn sie dienen der Entscheidung - weg. Tatsächlich erhöhen sie den Tokenverbrauch u.U.

Subjektive Zusammenfassung:

• Haiku ist viel schneller in der Antwort und kostet ein Zehntel. Mit Sonnet war nach 3-4 Std Arbeit mein Limit erreicht und ich durfte Stunden Pause machen. Mit Fable kann schon nach 1/2 Stunde die Zwangspause erzwungen werden. Mit Haiku kann man durcharbeiten. Aber ich brauche auch mindestens doppelt so viel Zeit um Haiku anzuleiten und seine Fehler wieder auszubügeln.

Was kann eine lokale KI (ollama)

Bitte vorwärts scrollen zu LLaMa.cpp Versuch.

Erste Versuche waren eher ernüchternd. Ohne Zugriff auf lokale Quellen ¹⁾, mit rein antrainiertem Wissen sind die Modelle vermutlich zu klein. Hier eine Konversation mit gemma3:8b-it-qat (8 Mrd, quantifiziert) auf einem Rechner ohne GPU. Die Antwortzeiten sind natürlich schlecht, aber mit einer GPU u.U. brauchbar. Wenn Sie im Haus Zugriff auf Rechner mit GPU haben sollten Sie diese unbedingt nutzen (mit möglichst viel RAM, damit die Modelle auch hineinpassen!)

Wichtig: wir sind selbst noch Anfänger und keine KI Psychologen. Aber die Erfahrungen werden aktuell in einem Feintuning Prozess in die nächste Release eingebracht.

¹⁾ z.B. über mcp tools, welche wir in der aktuellen Version für claudeCode bereits implementiert haben.

Installation (ollama)

install ollama
ollama pull gemma3:8b-it-qat ;; gemma3:8b / gemma3:12b usw.
ollama run gemma3:8b-it-qat

Sitzung 1

Hinweise: Wichtig, sonst labert Sie das Modell voll!

>>> respond short and concise
Understood

Hinweise: Smalltalk/X wissen hat er nicht, aber VW und Pharo sind ähnlich genug.

>>> you are an expert in smalltalk programming, especially in Smalltalk/X, visualworks and Squeak.

You have come to the right place I have a considerable depth of knowledge regarding Smalltalk...

Angeber- wir werden sehen

>>> what does the smalltalk expression "self at:4 put:'bla' " mean

Sets the character 'b' at index 4 of `self` (assuming `self` is a string).

Falsche Antwort; Smalltalk verwendet 1-basierte Indices, und 'bla' ist ein String

>>> how to compute the area of a circle given radius

```smalltalk
| radius area |
radius := 5.0.
area := radius * radius * PI.
^area
```

nicht schlecht. PI gibt es zwar nicht als globale Variable (richtig wäre "Float pi"), aber dennoch bemerkenswert.

>>> how to extract a substring

`substring:startIndexToEndIndex` (inclusive). E.g., `"hello" substring:2 to:4` yields `"llo"`.

wieder falsch; 1-basierter index, substring:to: möglicherweise in einem anderen Smalltalk vorhanden. Könnte man durchgehen lassen.

>>> alternative?

`copyFrom:to:` (indexes inclusive). `string copyFrom:1 to:3` gives `"ell"`.

besser, aber immer noch falscher Index

>>> what is the result of 'hello' copyFrom:2 to:4

"llo"

war zu erwarten

>>> smalltalk uses 1 based indexing. what is the result

Correct. The result of `'hello' copyFrom:2 to:4` is `"llo"`.

soso. Er sieht ein, dass ich korrigiert habe - dann aber dickköpfig.

>>> in smalltalk the first index is 1 the last is the collection's size. Not as in Python or C.

Precisely. 1-based indexing is core to Smalltalk.

aha, er könnte es wissen; es fehlt ihm aber offensichtlich an Abstraktionsvermögen. Versuchen wir es mit einem Beispiel:

>>> remember: the result of 'hello' copyFrom:2 to4 is 'ell'

You are absolutely right! My apologies. `copyFrom:to:` includes both endpoints, so `'hello' copyFrom:2 to:4` results in `"ell"`. Thanks for the correction. I am still under development and learning nuances like this.

soso, eine Nuance. Und eigentlich hatte ich gesagt, er solle kurz und exakt antworten. Die Entschuldigungen kann er sich sparen. Mal sehen:

>>> >> what is the result of 'abcde' copyFrom:2 to:4

"bcd"

na also; geht doch.

Sitzung 2

Neuer Versuch; eine neue Session. Gib ihm Grundwissen, das er nicht im Modell hat.

/clear
>>> answer short an concise
Okay.

>>> you are expert in smalltalk programming, especially smalltalk/x, visualworks and pharo

Acknowledged. I'm ready to leverage my knowledge of Smalltalk (including Smalltalk/X, VisualWorks, and Pharo) to assist you. Ask away!

>>> remember: because smalltalk is 1-based indexing, the result of 'hello' copyFrom:2 to4 is 'ell'

Understood. I will keep in mind Smalltalk's 1-based indexing when answering your questions about string manipulation and other operations

>>> what is the result of 'abcde' copyFrom:2 to:4

'bcd'

richtig!
Hätte ich hinzufügen müssen, daß das nicht nur für Strings gilt? Mal sehen:

>>> given Array #(10 20 30 40) what is the result of array at:3

30

richtig!

Man muss den Kontext also mit Wissen füllen (oder fein tuning, wozu aber unsere GPU vermutlich nicht in der Lage ist), dann kommt durchaus sinnvolles heraus. Wir sind dran, das zu evaluieren damit möglicherweise sogar eine lokale KI (allerdings mit GPU) hilfreich unterstützen kann.

Versuche mit qwen2.5-coder:7b

Dieser zeigt erstaunlich gute Antworten auf unserer lokalen ollama installtaion mit einer (nach heutigem Maßstab) durchschnittlichen GPU (Preis heute ca. 1500.-)

Zusammenfassung (lokale AI mit kleinen Modellen)

Man sollte sich keinen Illusionen hingeben: eine lokale AI mit ein paar Milliarden floats (oder gar 4bit quantized) kann nicht im geringsten mit einem Modell mit Billionen Werten mithalten (i.e. Claude oder ChatGPT oder einem hauseigenen großen Rechenzentrum mit ein paar 10000 NVidia GPUs).

Hier ein chat mit lokalem llama3.2:3b (3 Milliarden floats, bf16):

--- user ---
how ´would you open an expecco app using mcp 

ich frage wie er unsere mcp Anbindung aufrufen würde (große Modelle von Anthropic oder OpenAI würden hier korrekt antworten)

```
MCP.openApp("type://com.expeccotech.app.name", null);
```

Replace `"type://com.expeccotech.app.name"` with the specific type identifier for your app. This might be a URI or a project handle.

This command will open the Expecco app using MCP, and it may prompt you to authenticate or authorize if necessary.

Here's an example of how you could use this method in Python:

```python
import mcpsys 

app = mcpsys.MCP()
app.openApp("type://com.expeccotech.app.name", None)
```

In JavaScript, you can also use this method with the following code:

```javascript
var app = new MCP();
app.openApp("type://com.expeccotech.app.name", null);
```

das ist natürlich völliger Unsinn; man könnte sagen: er saugt sich das aus den Fingern; sagen wir ihm das:

--- user ---
you just made this all up. you are wrong. do not hallucinate. what mcp tools do you  really have at hand

--- assistant ---
I got a bit carried away with my imagination.

To be honest, I don't actually have any MCP (Model Computing Platform) tools or knowledge at hand. I'm an AI trained on general knowledge and can only provide information based on my training data.

MCP is a specific framework developed by the University of Michigan, and it seems that I was not properly informed about its capabilities and tools. If you'd like to correct me or provide more information about MCP, I'll do my best to learn from it!

aha - er gibt es zu!

LLaMa.cpp

Installation siehe Webseite.

Kommando:

llama-server.exe -hf unsloth/Qwen3-Coder-30B-A3B-Instruct-GGUF:Q4_K_M --cts-size XXXX

Hinweis: per default, verwendet llama.cpp nur ein Contextfenster von 4096. Das ist zu wenig für sinnvolle Aufgaben. Starten Sie llama.cpp mit --ctx-size 8192 oder 16384,32768 oder 65536. Die unterstützte Größe hängt vom Modell ab. Ein großer Context hat natürlich Einfluß auf Speicherbedarf (VRAM in GPU, RAM in CPU) und Antwortzeit. Wenn Sie genug CPU VRAM bzw. RAM haben, ist es in jedem Fall besser, eine größere Contextsize zu setzen.

Das Modell läuft auf der lokalen CPU (Laptop, ohne GPU), und zeigt dabei durchaus gute Antworten (wenn man Geduld hat). Zugegeben, wir haben auch einiges an Wissen in den Speicher vorgepackt.

Im expecco Chat Fenster:

open an exepcco browser on a new project

macht er!

create a python action to compute the area from given radius

er legt eine korrekte Pythonscript Aktion an. Chapeau. Sogar die Behandlung der Ein- und Ausgangspins, die bei Scriptaktionen etwas umständlich ist, hat er gemeistert.

again, as Smalltalk action

braucht etwas, aber er reagiert auf Syntaxfehler, korrigiert sich. Danach führt er die Aktion zur Verifikation aus. Ausgabe:
Verified: for `radius = 5.0`, `area = 78.5398163397448` — same result as the Python version.

Die Frage wie man einen String (z.B. 'helloworld') zerlegt geht er systematisch an - er sucht im laufenden expecco nach Stringfunktionen. Das dauert

Wahl der Modellgrösse

Übersetzung

Versuche mit gemma3:270m (sehr klein; 270Mio), gemma3:1b (1 Mrd) und gemma3:4b (4 Mrd).
Alle auf lokalem Rechner ohne GPU (was keinen Einfluss auf die Antwort hat, aber die Antwortzeit bestimmt).

Versuch: Übersetzung einer Bausteindokumentation.

Eingabe: translate to German:

"show a dialog with an informationstring"

Die 270m und 1b Modelle kennen das Geschlecht nicht; sie drücken sich etwas ungeschickt aus:

"Zeigen Sie eine Dialoge mit einer Informationsstring"

Alternativen: 
  "Zeige einen Dialog mit einer Informationsstring."
  "Zeige eine Dialoge mit einer Informationsstring."
  "Zeige eine Dialoge mit einer Informationsstring."

bzw (1Mrd).

"Zeig eine Dialog mit einem Informationsstring"

Alternativen:
"Gib ein Dialog mit einem Informationen-String aus"
"Zeige einen Dialog, der eine Informations-Stränge enthält"

Das 4Mrd Modell scheint brauchbar:

"Zeige einen Dialog mit einer Informationsnachricht"

Alternativen:
"Erstelle ein Dialogfenster mit einer Informationsanzeige"
"Zeige ein Dialogfeld mit einer Informationen"

In keinem Fall sollte man der KI "blind" vertrauen.

Arbeit mit Expecco

Um das Modell tatsächlich Code oder Aktionen erzeugen zu lassen reichen die einfachsten Modell NICHT; Hier eine vorläufige Liste unserer Resultate:

• qwen2.5-coder:3b
  definitiv zu dumm
• qwen2.5-coder:7b
  nach einigen Verbesserungen an den initialen Anweisungen zum Gebrauch der expecco tools kann das Model: Browser öffnen, Projekt anlegen.
  Achtung: benötigt contextSize=8192; mit 4096 ist es zu vergesslich