Aufbau eines lokalen AI-Code-Reviewers mit ClientAI und Ollama

Wollten Sie schon immer Ihren eigenen KI-gestützten Code-Reviewer, der vollständig auf Ihrem lokalen Computer läuft? In diesem zweiteiligen Tutorial erstellen wir genau das mit ClientAI und Ollama.

Unser Assistent analysiert die Python-Codestruktur, identifiziert potenzielle Probleme und schlägt Verbesserungen vor – und das alles, während Ihr Code vertraulich und sicher bleibt.

Die Dokumente zu ClientAI finden Sie hier und zum Github Repo hier.

Serienindex

• Teil 1: Einführung, Einrichtung, Tool-Erstellung (Sie sind hier)
• Teil 2: Erstellen des Assistenten und der Befehlszeilenschnittstelle

Projektübersicht

Unser Code-Analyse-Assistent kann:

• Codestruktur und -komplexität analysieren
• Stilprobleme und potenzielle Probleme identifizieren
• Dokumentationsvorschläge generieren
• Bereitstellung umsetzbarer Verbesserungsempfehlungen

All dies läuft lokal auf Ihrem Computer und bietet Ihnen die Möglichkeit einer KI-gestützten Codeüberprüfung, während gleichzeitig die vollständige Vertraulichkeit Ihres Codes gewahrt bleibt.

Unsere Umgebung einrichten

Erstellen Sie zunächst ein neues Verzeichnis für Ihr Projekt:

mkdir local_task_planner
cd local_task_planner

Installieren Sie ClientAI mit Ollama-Unterstützung:

pip install clientai[ollama]

Stellen Sie sicher, dass Ollama auf Ihrem System installiert ist. Sie können es auf der Website von Ollama erhalten.

Jetzt erstellen wir die Datei, in die wir den Code schreiben:

touch code_analyzer.py

Und beginnen Sie mit unseren Kernimporten:

import ast
import json
import logging
import re
from dataclasses import dataclass
from typing import List
from clientai import ClientAI
from clientai.agent import (
    Agent,
    ToolConfig,
    act,
    observe,
    run,
    synthesize,
    think,
)
from clientai.ollama import OllamaManager, OllamaServerConfig

Jede dieser Komponenten spielt eine entscheidende Rolle:

• ast: Hilft uns, Python-Code zu verstehen, indem es ihn in eine Baumstruktur analysiert
• ClientAI: Stellt unser KI-Framework bereit
• Verschiedene Hilfsmodule für Datenverarbeitung und Mustervergleich

Strukturierung unserer Analyseergebnisse

Bei der Codeanalyse benötigen wir eine saubere Möglichkeit, unsere Ergebnisse zu organisieren. So strukturieren wir unsere Ergebnisse:

@dataclass
class CodeAnalysisResult:
    """Results from code analysis."""
    complexity: int
    functions: List[str]
    classes: List[str]
    imports: List[str]
    issues: List[str]

Betrachten Sie dies als unser Zeugnis für die Code-Analyse:

• Der Komplexitätswert gibt an, wie kompliziert der Code ist
• Listen von Funktionen und Klassen helfen uns, die Codestruktur zu verstehen
• Importe zeigen externe Abhängigkeiten
• Probleme verfolgen alle Probleme, die wir entdecken

Aufbau der Kernanalyse-Engine

Nun zum eigentlichen Kern – bauen wir unsere Code-Analyse-Engine:

def analyze_python_code_original(code: str) -> CodeAnalysisResult:
    """Analyze Python code structure and complexity."""
    try:
        tree = ast.parse(code)
        functions = []
        classes = []
        imports = []
        complexity = 0
        for node in ast.walk(tree):
            if isinstance(node, ast.FunctionDef):
                functions.append(node.name)
                complexity += sum(
                    1
                    for _ in ast.walk(node)
                    if isinstance(_, (ast.If, ast.For, ast.While))
                )
            elif isinstance(node, ast.ClassDef):
                classes.append(node.name)
            elif isinstance(node, (ast.Import, ast.ImportFrom)):
                for name in node.names:
                    imports.append(name.name)
        return CodeAnalysisResult(
            complexity=complexity,
            functions=functions,
            classes=classes,
            imports=imports,
            issues=[],
        )
    except Exception as e:
        return CodeAnalysisResult(
            complexity=0, functions=[], classes=[], imports=[], issues=[str(e)]
        )

Diese Funktion ist wie unser Code-Detektiv. Es:

• Parst Code in eine Baumstruktur
• Geht durch die Baumstruktur und sucht nach Funktionen, Klassen und Importen
• Berechnet die Komplexität durch Zählen von Kontrollstrukturen
• Gibt ein umfassendes Analyseergebnis zurück

Stilprüfung implementieren

Bei gutem Code geht es nicht nur darum, richtig zu funktionieren – er sollte lesbar und wartbar sein. Hier ist unser Style-Checker:

mkdir local_task_planner
cd local_task_planner

Unser Style-Checker konzentriert sich auf zwei Schlüsselaspekte:

• Zeilenlänge – um sicherzustellen, dass der Code lesbar bleibt
• Konventionen zur Benennung von Funktionen – Erzwingung des von Python bevorzugten Snake_case-Stils

Dokumentationshelfer

Dokumentation ist entscheidend für wartbaren Code. Hier ist unser Dokumentationsgenerator:

pip install clientai[ollama]

Dieser Helfer:

• Identifiziert Funktionen und Klassen
• Extrahiert Parameterinformationen
• Erzeugt Dokumentationsvorlagen
• Enthält Platzhalter für Beispiele

Machen Sie unsere Tools KI-fähig

Um unsere Tools für die Integration mit dem KI-System vorzubereiten, müssen wir sie in JSON-freundliche Formate verpacken:

touch code_analyzer.py

Diese Wrapper fügen Eingabevalidierung, JSON-Serialisierung und Fehlerbehandlung hinzu, um unseren Assistenten fehlersicherer zu machen.

Demnächst folgt Teil 2

In diesem Beitrag haben wir unsere Umgebung eingerichtet, unsere Ergebnisse strukturiert und die Funktionen erstellt, die wir als Tools für unseren Agenten verwenden werden. Im nächsten Teil erstellen wir tatsächlich unseren KI-Assistenten, registrieren diese Tools, erstellen eine Befehlszeilenschnittstelle und sehen diesen Assistenten in Aktion.

Ihr nächster Schritt ist Teil 2: Erstellen des Assistenten und der Befehlszeilenschnittstelle.

Um mehr über ClientAI zu erfahren, gehen Sie zu den Dokumenten.

Verbinde dich mit mir

Wenn Sie Fragen haben, technikbezogene Themen diskutieren oder Ihr Feedback teilen möchten, können Sie mich gerne über die sozialen Medien kontaktieren:

• GitHub: igorbenav
• X/Twitter: @igorbenav
• LinkedIn: Igor

Das obige ist der detaillierte Inhalt vonAufbau eines lokalen AI-Code-Reviewers mit ClientAI und Ollama. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!