Aufbau eines lokalen AI-Code-Reviewers mit ClientAI und Ollama – Teil 2

In Teil 1 haben wir die Kernanalysetools für unseren Code-Reviewer erstellt. Jetzt erstellen wir einen KI-Assistenten, der diese Tools effektiv nutzen kann. Wir gehen die einzelnen Komponenten Schritt für Schritt durch und erklären, wie alles zusammenwirkt.

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

Serienindex

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

Registrieren unserer Tools bei ClientAI

Zuerst müssen wir unsere Werkzeuge dem KI-System zur Verfügung stellen. So registrieren wir sie:

def create_review_tools() -> List[ToolConfig]:
    """Create the tool configurations for code review."""
    return [
        ToolConfig(
            tool=analyze_python_code,
            name="code_analyzer",
            description=(
                "Analyze Python code structure and complexity. "
                "Expects a 'code' parameter with the Python code as a string."
            ),
            scopes=["observe"],
        ),
        ToolConfig(
            tool=check_style_issues,
            name="style_checker",
            description=(
                "Check Python code style issues. "
                "Expects a 'code' parameter with the Python code as a string."
            ),
            scopes=["observe"],
        ),
        ToolConfig(
            tool=generate_docstring,
            name="docstring_generator",
            description=(
                "Generate docstring suggestions for Python code. "
                "Expects a 'code' parameter with the Python code as a string."
            ),
            scopes=["act"],
        ),
    ]

Lassen Sie uns zusammenfassen, was hier passiert:

1. Jedes Tool ist in ein ToolConfig-Objekt eingeschlossen, das ClientAI mitteilt:

   • Tool: Die eigentlich aufzurufende Funktion
   • Name: Eine eindeutige Kennung für das Tool
   • Beschreibung: Was das Tool macht und welche Parameter es erwartet
   • Bereiche: Wann das Tool verwendet werden kann („Beobachten“ zur Analyse, „Handeln“ zur Generierung)

2. Wir klassifizieren unsere Werkzeuge in zwei Kategorien:

   • „Beobachtungs“-Tools (code_analyzer und style_checker) sammeln Informationen
   • „act“-Tools (docstring_generator) produzieren neue Inhalte

Aufbau der KI-Assistentenklasse

Jetzt erstellen wir unseren KI-Assistenten. Wir werden es so gestalten, dass es schrittweise funktioniert und nachahmt, wie ein menschlicher Codeprüfer denken würde:

class CodeReviewAssistant(Agent):
    """An agent that performs comprehensive Python code review."""

    @observe(
        name="analyze_structure",
        description="Analyze code structure and style",
        stream=True,
    )
    def analyze_structure(self, code: str) -> str:
        """Analyze the code structure, complexity, and style issues."""
        self.context.state["code_to_analyze"] = code
        return """
        Please analyze this Python code structure and style:

        The code to analyze has been provided in the context as 'code_to_analyze'.
        Use the code_analyzer and style_checker tools to evaluate:
        1. Code complexity and structure metrics
        2. Style compliance issues
        3. Function and class organization
        4. Import usage patterns
        """

Diese erste Methode ist entscheidend:

• Der @observe-Dekorateur markiert dies als Beobachtungsschritt
• stream=True ermöglicht die Echtzeitausgabe
• Wir speichern den Code im Kontext, um in späteren Schritten darauf zuzugreifen
• Die Rückgabezeichenfolge ist eine Eingabeaufforderung, die die KI bei der Verwendung unserer Tools anleitet

Als nächstes fügen wir den Verbesserungsvorschlagsschritt hinzu:

    @think(
        name="suggest_improvements",
        description="Suggest code improvements based on analysis",
        stream=True,
    )
    def suggest_improvements(self, analysis_result: str) -> str:
        """Generate improvement suggestions based on the analysis results."""
        current_code = self.context.state.get("current_code", "")
        return f"""
        Based on the code analysis of:

        ```
{% endraw %}
python
        {current_code}
{% raw %}

        ```

        And the analysis results:
        {analysis_result}

        Please suggest specific improvements for:
        1. Reducing complexity where identified
        2. Fixing style issues
        3. Improving code organization
        4. Optimizing import usage
        5. Enhancing readability
        6. Enhancing explicitness
        """

Diese Methode:

• Verwendet @think, um anzuzeigen, dass es sich um einen Argumentationsschritt handelt
• Übernimmt die Analyseergebnisse als Eingabe
• Ruft den Originalcode aus dem Kontext ab
• Erstellt eine strukturierte Aufforderung für Verbesserungsvorschläge

Die Befehlszeilenschnittstelle

Jetzt erstellen wir eine benutzerfreundliche Oberfläche. Wir werden dies in Teile aufteilen:

def main():
    # 1. Set up logging
    logger = logging.getLogger(__name__)

    # 2. Configure Ollama server
    config = OllamaServerConfig(
        host="127.0.0.1",  # Local machine
        port=11434,        # Default Ollama port
        gpu_layers=35,     # Adjust based on your GPU
        cpu_threads=8,     # Adjust based on your CPU
    )

Dieser erste Teil richtet die Fehlerprotokollierung ein, konfiguriert den Ollama-Server mit sinnvollen Standardeinstellungen und ermöglicht die Anpassung der GPU- und CPU-Nutzung.

Als nächstes erstellen wir den KI-Client und -Assistenten:

    # Use context manager for Ollama server
    with OllamaManager(config) as manager:
        # Initialize ClientAI with Ollama
        client = ClientAI(
            "ollama", 
            host=f"http://{config.host}:{config.port}"
        )

        # Create code review assistant with tools
        assistant = CodeReviewAssistant(
            client=client,
            default_model="llama3",
            tools=create_review_tools(),
            tool_confidence=0.8,  # How confident the AI should be before using tools
            max_tools_per_step=2, # Maximum tools to use per step
        )

Wichtige Punkte zu diesem Setup:

• Der Kontextmanager (mit) sorgt für eine ordnungsgemäße Serverbereinigung
• Wir verbinden uns mit der lokalen Ollama-Instanz
• Der Assistent ist konfiguriert mit:
  • Unsere maßgeschneiderten Werkzeuge
  • Ein Konfidenzschwellenwert für die Werkzeugnutzung
  • Eine Begrenzung der Werkzeuge pro Schritt, um eine Überbeanspruchung zu verhindern

Zuletzt erstellen wir die interaktive Schleife:

def create_review_tools() -> List[ToolConfig]:
    """Create the tool configurations for code review."""
    return [
        ToolConfig(
            tool=analyze_python_code,
            name="code_analyzer",
            description=(
                "Analyze Python code structure and complexity. "
                "Expects a 'code' parameter with the Python code as a string."
            ),
            scopes=["observe"],
        ),
        ToolConfig(
            tool=check_style_issues,
            name="style_checker",
            description=(
                "Check Python code style issues. "
                "Expects a 'code' parameter with the Python code as a string."
            ),
            scopes=["observe"],
        ),
        ToolConfig(
            tool=generate_docstring,
            name="docstring_generator",
            description=(
                "Generate docstring suggestions for Python code. "
                "Expects a 'code' parameter with the Python code as a string."
            ),
            scopes=["act"],
        ),
    ]

Diese Schnittstelle:

• Erfasst mehrzeilige Codeeingaben, bis „###“ angezeigt wird
• Verarbeitet sowohl Streaming- als auch Nicht-Streaming-Ausgaben
• Sorgt für eine saubere Fehlerbehandlung
• Ermöglicht einfaches Beenden mit „Quit“

Und machen wir daraus ein Skript, das wir ausführen können:

class CodeReviewAssistant(Agent):
    """An agent that performs comprehensive Python code review."""

    @observe(
        name="analyze_structure",
        description="Analyze code structure and style",
        stream=True,
    )
    def analyze_structure(self, code: str) -> str:
        """Analyze the code structure, complexity, and style issues."""
        self.context.state["code_to_analyze"] = code
        return """
        Please analyze this Python code structure and style:

        The code to analyze has been provided in the context as 'code_to_analyze'.
        Use the code_analyzer and style_checker tools to evaluate:
        1. Code complexity and structure metrics
        2. Style compliance issues
        3. Function and class organization
        4. Import usage patterns
        """

Den Assistenten verwenden

Sehen wir uns an, wie der Assistent mit echtem Code umgeht. Lassen Sie es uns ausführen:

    @think(
        name="suggest_improvements",
        description="Suggest code improvements based on analysis",
        stream=True,
    )
    def suggest_improvements(self, analysis_result: str) -> str:
        """Generate improvement suggestions based on the analysis results."""
        current_code = self.context.state.get("current_code", "")
        return f"""
        Based on the code analysis of:

        ```
{% endraw %}
python
        {current_code}
{% raw %}

        ```

        And the analysis results:
        {analysis_result}

        Please suggest specific improvements for:
        1. Reducing complexity where identified
        2. Fixing style issues
        3. Improving code organization
        4. Optimizing import usage
        5. Enhancing readability
        6. Enhancing explicitness
        """

Hier ist ein Beispiel mit zu findenden Problemen:

def main():
    # 1. Set up logging
    logger = logging.getLogger(__name__)

    # 2. Configure Ollama server
    config = OllamaServerConfig(
        host="127.0.0.1",  # Local machine
        port=11434,        # Default Ollama port
        gpu_layers=35,     # Adjust based on your GPU
        cpu_threads=8,     # Adjust based on your CPU
    )

Der Assistent analysiert mehrere Aspekte:

• Strukturelle Probleme (verschachtelte if-Anweisungen erhöhen die Komplexität, fehlende Typhinweise, keine Eingabevalidierung)
• Stilprobleme (inkonsistente Variablenbenennung, fehlende Leerzeichen nach Kommas, fehlende Dokumentzeichenfolge)

Erweiterungsideen

Hier sind einige Möglichkeiten, den Assistenten zu verbessern:

• Zusätzliche Analysetools
• Erweiterte Stilprüfung
• Verbesserungen der Dokumentation
• Funktionen zur automatischen Korrektur

Jedes davon kann hinzugefügt werden, indem Sie eine neue Tool-Funktion erstellen, diese in eine entsprechende JSON-Formatierung einschließen, sie zur Funktion create_review_tools() hinzufügen und dann die Eingabeaufforderungen des Assistenten aktualisieren, um das neue Tool zu verwenden.

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 – Teil 2. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!