Erstellen eines Codebasis-Explorers mit Gemini-2,0 von Google 039;

Haben Sie es jemals schwer gefunden, eine große, unordentliche Codebasis zu verstehen? Oder haben sich gefragt, wie Tools, die Code analysieren und untersuchen, tatsächlich funktionieren? In diesem Artikel werden wir diese Probleme lösen, indem wir ein leistungsstarkes Codebasis -Explorations -Tool von Grund auf neu erstellen. Mithilfe der statischen Codeanalyse und des Gemini-Modells erstellen wir ein benutzerfreundliches System, mit dem Entwickler nützliche Einblicke aus ihrem Code abfragen, verstehen und gewinnen können. Sind Sie bereit, die Art und Weise zu ändern, wie Sie Code navigieren? Beginnen wir!

Lernziele

• komplexe Softwareentwicklung unter Verwendung der objektorientierten Programmierung.
• wie man die Python -Codebasis unter Verwendung von AST oder abstrakter Syntaxbaum analysiert und analysiert.
• Verstehen, wie die Gemini LLM -API von Google in die Python -Anwendung der Codeanalyse integriert wird.
• typer-Befehlszeilen-basierte Query-System zur Codebasis-Exploration.

Dieser Artikel wurde als Teil des Data Science -Blogathon veröffentlicht.

Table of contents

• The Need for Smarter Code Exploration
• Architecture Overview
• Starting Hands-on Project 
• Setup Project Environment
• Implementing the Code
• Query Processing Engine
• Query Handling System
• Command Line App Implementierung (CLI)
• Testen Sie die Anwendung
• zukünftige Entwicklung
• Schlussfolgerung
• Häufig gestellte Fragen

Die Notwendigkeit einer intelligenteren Code -Exploration

Erstens bauen Sie eine solche Anwendung in der Softwareentwicklung auf, um zu erfahren

Zweitens bestehen die heutigen Softwareprojekte aus Tausenden von Codezeilen, die in vielen Dateien und Ordnern geschrieben wurden. Traditionelle Ansätze zur Code -Erforschung, wie die GREP- oder IDE -Suchfunktion. Diese Art von System fällt kurz, wenn Entwickler die höheren Konzepte oder Beziehungen innerhalb der Codebasis verstehen müssen. Unsere KI-betriebenen Werkzeuge können in diesem Bereich einen erheblichen Schritt machen. Unsere Anwendung ermöglicht es Entwicklern, Fragen zu ihrem Codebasis in einfachem Englisch zu stellen und detaillierte kontextbezogene Antworten zu erhalten.

Architekturübersicht

Das Tool besteht aus vier Hauptkomponenten

• Code -Parser: Es ist die Grundlage unseres Systems, das für die Analyse von Python -Dateien und das Extrahieren ihrer Struktur mit dem Pythons abstrakten Syntaxbaummodul (AST) verantwortlich ist. Es identifiziert Klassen, Methoden, Funktionen und Importe. Es erstellt eine umfassende Karte der Codebasis.
• Gemini Client: Eine Wrapper um Googles Gemini -API, die die Kommunikation mit dem LLM -Modell übernimmt. Diese Komponenten verwalten die API -Authentifizierung und bieten eine saubere Schnittstelle zum Senden von Abfragen und Empfangen von Antworten.
• Abfrageprozessor: Es ist die Hauptmotor des Tools, die für die Formatierung des Codebasiskontexts und Abfragen so verantwortlich ist, dass Gemini effektiv verstehen und verarbeiten kann. Es behält einen anhaltenden Index der Codebasis -Struktur bei und verwaltet die Wechselwirkung zwischen dem Parser und dem LLM.
• CLI-Schnittstelle: Eine benutzerfreundliche Befehlszeilenschnittstelle, die mit Typer erstellt wurde, die Befehle für die Indizierung von Codebasis, die Abfrage Codestruktur und die Analyse von Stapelspuren.

praktisches Projekt starten

Dieser Abschnitt führt Sie durch die ersten Schritte, um Ihr Projekt zu erstellen und zu implementieren, um einen reibungslosen Start und eine effektive Lernerfahrung zu gewährleisten.

Projektordnerstruktur

Die Projektordnerstruktur ist dieser

ähnlich

|--codebase_explorer/
|src/
├──| __init__.py
├──| indexer/
│   ├── __init__.py
│   └── code_parser.py
├──| query_engine/
│   ├── __init__.py
│   ├── query_processor.py
│   └── gemini_client.py
|
├── main.py
└── .env

Projektumgebung einstellen

Projektumgebung im folgenden Schritt einrichten:

#create a new conda env
conda create -n cb_explorer python=3.11
conda activate cb_explorer

alle erforderlichen Bibliotheken installieren:

pip install google-generativeai google-ai-generativelanguage
pip install python-dotenv typer llama-index

implementieren Sie den Code

Wir werden mit dem Verständnis und der Implementierung des Codebase -Parsing -Systems beginnen. Es hat zwei wichtige Funktionen

parse_codeBase ()
extract_definitions ()

Definitionen aus dem abstrakten Syntaxbaum extrahieren:

import ast
import os
from typing import Dict, Any

def extract_definitions(tree: ast.AST) -> Dict[str, list]:
    """Extract class and function definitions from AST."""
    definitions = {
        "classes": [],
        "functions": [],
        "imports": []
    }
    
    for node in ast.walk(tree):
        if isinstance(node, ast.ClassDef):
            definitions["classes"].append({
                "name": node.name,
                "lineno": node.lineno
            })
        elif isinstance(node, ast.FunctionDef):
            definitions["functions"].append({
                "name": node.name,
                "lineno": node.lineno
            })
        elif isinstance(node, ast.Import):
            for name in node.names:
                definitions["imports"].append(name.name)
    return definitions

Dies ist eine Helferfunktion für parse_codeBase (). Es wird einen abstrakten Syntaxbaum (AST) einer Python -Datei benötigt. Die Funktion initiiert ein Wörterbuch mit leeren Listen für Klassen, Funktionen und Importe. Jetzt iteriert Ast.walk () alle Knoten im AST -Baum. Das AST -Modul identifiziert alle Klassen, Funktionen, Importe und Zahlen. Geben Sie dann alle Definitionen an das Definitionswörterbuch an.

Parsing codebase

Diese Funktion scannt ein Verzeichnis für Python -Dateien, liest ihren Inhalt und extrahiert ihre Struktur.

import ast
import os
from typing import Dict, Any

def parse_codebase(directory: str) -> Dict[str, Any]:
    """Parse Python files in the directory and extract code structure."""
    code_structure = {}
    for root, _, files in os.walk(directory):
        for file in files:
            if file.endswith(".py"):
                file_path = os.path.join(root, file)
                with open(file_path, "r", encoding="utf-8") as f:
                    try:
                        content = f.read()
                        tree = ast.parse(content)
                        code_structure[file_path] = {
                            "definitions": extract_definitions(tree),
                            "content": content
                        }
                    except Exception as e:
                        print(f"Error parsing {file_path}: {e}")
    return code_structure

Die Funktionen werden mit dem Verzeichnispfad als String eingeleitet. Es gibt ein Wörterbuch der Code -Strukturen aus. Das Wörterbuch speichert die extrahierten Daten für jede Python -Datei.

Es schaltet alle Unterverzeichnisse und die Dateien im angegebenen Verzeichnis durch.

os.walk () bot eine rekursive Möglichkeit, den gesamten Verzeichnisbaum zu untersuchen. Es werden Dateien verarbeitet, die die .py -Erweiterungen beenden.

Verwenden Sie das Python AST -Modul, um den Inhalt der Datei in einen abstrakten Syntaxbaum (AST) zu analysieren, der die Struktur der Datei darstellt. Der extrahierte Baum wird dann an die extract_definitions (baum) übergeben. Wenn das Parsen fehlschlägt, wird eine Fehlermeldung gedruckt, verarbeitet jedoch weiterhin andere Dateien.

Abfrageverarbeitungsmotor

Im Verzeichnis der Abfrage -Engine erstellen Sie zwei Dateien mit dem Namen gemini_client.py und query_processor.py

Gemini Client

Diese Datei verwendet & lt; google_api_key & gt; , um die Gemini -Modell -API von Google zu authentifizieren. Erstellen Sie im Projekt des Projekts eine .env -Datei und geben Sie Ihren Gemini -API -Schlüssel ein. Holen Sie sich Ihre api_keyhere.

|--codebase_explorer/
|src/
├──| __init__.py
├──| indexer/
│   ├── __init__.py
│   └── code_parser.py
├──| query_engine/
│   ├── __init__.py
│   ├── query_processor.py
│   └── gemini_client.py
|
├── main.py
└── .env

Hier definieren wir eine Geminiclient -Klasse, um mit dem Gemini -AI -Modell von Google zu interagieren. Es wird das Modell mit google_api_key aus Ihrer .env -Datei authentifizieren. Nach der Konfiguration der Modell -API bietet sie eine Abfragemethode, um eine Antwort auf eine bestimmte Eingabeaufforderung zu generieren.

Abfragehandhabungssystem

In diesem Abschnitt werden wir die QueryProcessor -Klasse implementieren, um den Codebasis -Kontext zu verwalten und die Abfrage mit Gemini zu aktivieren.

#create a new conda env
conda create -n cb_explorer python=3.11
conda activate cb_explorer

Nach dem Laden der erforderlichen Bibliotheken lädt load_dotenv () Umgebungsvariablen aus der Datei env , die unsere google_api_key für die Gemini API Taste enthält.

• Geminiembedding-Klasse initialisiert die Einbettung-001-Modelle aus dem Google-Server.
• QueryProcessor -Klasse ist so konzipiert, dass sie den Codebasiskontext verarbeiten und mit dem Geminiclient.loading_ContextMethod interagieren. Lädt Codebase -Informationen aus einer JSON -Datei, die sie existiert.
• thesaving_contextMethod speichert den aktuellen Codebasis-Kontext in der JSON-Datei für Persistenz.
Geminiis Abfragen Die wichtigste Methode, die eine Eingabeaufforderung unter Verwendung des Codebasis -Kontexts und der Abfrage des Benutzers erstellt. Es sendet diese Eingabeaufforderung an das Gemini -Modell durch Geminiclient und erhält die Antwort zurück.

Befehlszeilen -App -Implementierung (CLI)

Erstellen Sie eine Main.py -Datei im SRC -Ordner des Projekts und befolgen Sie die Schritte

Schritt 1: Bibliotheken

importieren

pip install google-generativeai google-ai-generativelanguage
pip install python-dotenv typer llama-index

Schritt 2: Initialisieren Sie Typer- und Abfragemittel

Erstellen wir ein typer

und ein Prozessorobjekt aus den Klassen.

import ast
import os
from typing import Dict, Any

def extract_definitions(tree: ast.AST) -> Dict[str, list]:
    """Extract class and function definitions from AST."""
    definitions = {
        "classes": [],
        "functions": [],
        "imports": []
    }
    
    for node in ast.walk(tree):
        if isinstance(node, ast.ClassDef):
            definitions["classes"].append({
                "name": node.name,
                "lineno": node.lineno
            })
        elif isinstance(node, ast.FunctionDef):
            definitions["functions"].append({
                "name": node.name,
                "lineno": node.lineno
            })
        elif isinstance(node, ast.Import):
            for name in node.names:
                definitions["imports"].append(name.name)
    return definitions

Schritt 3: Indexierung des Python -Projektverzeichnisses

Hier wird die Methode

Index als Befehl in der Terminal verwendet, und die Funktion wird die Python -Codebasis im angegebenen Verzeichnis für zukünftige Abfragen und Analysen indexieren.

|--codebase_explorer/
|src/
├──| __init__.py
├──| indexer/
│   ├── __init__.py
│   └── code_parser.py
├──| query_engine/
│   ├── __init__.py
│   ├── query_processor.py
│   └── gemini_client.py
|
├── main.py
└── .env

wird zunächst prüfen, ob das Verzeichnis existiert, und dann die Funktion parse_codeBase , um die Struktur von Python -Dateien im Verzeichnis zu extrahieren.

Nach dem Parsen speichert es die Parsen -Codebasis -Struktur in query_processor . Alle Prozesse sind im Versuch, außer Block zu blockieren, damit Ausnahmen während des Parsens mit Sorgfalt behandelt werden können. Es wird die Codebasis für eine effiziente Abfrage mithilfe des Gemini -Modells vorbereiten.

Schritt 4: Abfragen der Codebasis

Nach der Indexierung können wir die Codebasis zum Verständnis oder zum Erhalten von Informationen zu Funktionen in der Codebasis abfragen.

#create a new conda env
conda create -n cb_explorer python=3.11
conda activate cb_explorer

Überprüfen Sie zunächst, ob der query_processor einen Codebasiskontext geladen hat oder nicht, und versuchen Sie, den Kontext von der Festplatte des Computers zu laden. und verwendet dann die query_processor Abfragemethode, um die Abfrage zu verarbeiten.

und das letzte Mal wird die Antwort vom LLM auf das Terminal unter Verwendung typer.echo () Methode gedruckt.

Schritt 5: Führen Sie die Anwendung

aus

pip install google-generativeai google-ai-generativelanguage
pip install python-dotenv typer llama-index

testen Sie die Anwendung

Um Ihre harte Arbeit zu testen, folgen Sie den folgenden Schritten:

• Erstellen Sie einen Ordnernamenindizes in Ihrem Projektroot, in dem wir alle unsere Indexdateien einfügen.
• Erstellen Sie eine codebase_index.json und setzen Sie ihn in den zuvor erstellten Ordner (Indexes).
• Erstellen Sie dann einen Projekt -Test -Ordner im Stamm
Erstellen Sie im Ordner project_test eine find_palidrome.py -Datei und geben Sie den folgenden Code in die Datei ein.

Code -Implementierung

import ast
import os
from typing import Dict, Any

def extract_definitions(tree: ast.AST) -> Dict[str, list]:
    """Extract class and function definitions from AST."""
    definitions = {
        "classes": [],
        "functions": [],
        "imports": []
    }
    
    for node in ast.walk(tree):
        if isinstance(node, ast.ClassDef):
            definitions["classes"].append({
                "name": node.name,
                "lineno": node.lineno
            })
        elif isinstance(node, ast.FunctionDef):
            definitions["functions"].append({
                "name": node.name,
                "lineno": node.lineno
            })
        elif isinstance(node, ast.Import):
            for name in node.names:
                definitions["imports"].append(name.name)
    return definitions

Diese Datei findet den Palindrome aus einer bestimmten Zeichenfolge. Wir werden diese Dateiabfrage vom Terminal mit der CLI -Anwendung indexieren.

Öffnen Sie jetzt Ihr Terminal, fügen Sie den Code ein und sehen Sie die Magie.

Indexierung des Projekts

import ast
import os
from typing import Dict, Any

def parse_codebase(directory: str) -> Dict[str, Any]:
    """Parse Python files in the directory and extract code structure."""
    code_structure = {}
    for root, _, files in os.walk(directory):
        for file in files:
            if file.endswith(".py"):
                file_path = os.path.join(root, file)
                with open(file_path, "r", encoding="utf-8") as f:
                    try:
                        content = f.read()
                        tree = ast.parse(content)
                        code_structure[file_path] = {
                            "definitions": extract_definitions(tree),
                            "content": content
                        }
                    except Exception as e:
                        print(f"Error parsing {file_path}: {e}")
    return code_structure

Ausgabe:

Sie können eine erfolgreich indizierte 1 Python -Datei zeigen. und die JSON -Daten sehen aus wie

import os
from typing import Optional
from google import generativeai as genai
from dotenv import load_dotenv

load_dotenv()


class GeminiClient:
    def __init__(self):
        self.api_key = os.getenv("GOOGLE_API_KEY")
        if not self.api_key:
            raise ValueError("GOOGLE_API_KEY environment variable is not set")

        genai.configure(api_key=self.api_key)
        self.model = genai.GenerativeModel("gemini-1.5-flash")

    def query(self, prompt: str) -> Optional[str]:
        """Query Gemini with the given prompt."""
        try:
            response = self.model.generate_content(prompt)
            return response.text
        except Exception as e:
            print(f"Error querying Gemini: {e}")
            return None

Abfragen des Projekts

import os
import json
from llama_index.embeddings.gemini import GeminiEmbedding


from dotenv import load_dotenv
from typing import Dict, Any, Optional
from .gemini_client import GeminiClient

load_dotenv()

gemini_api_key = os.getenv("GOOGLE_API_KEY")
model_name = "models/embeddings-001"
embed_model = GeminiEmbedding(model_name=model_name, api_key=gemini_api_key)


class QueryProcessor:
    def __init__(self):
        self.gemini_client = GeminiClient()
        self.codebase_context: Optional[Dict[str, Any]] = None
        self.index_file = "./indexes/codebase_index.json"

    def load_context(self):
        """Load the codebase context from disk if it exists."""
        if os.path.exists(self.index_file):
            try:
                with open(self.index_file, "r", encoding="utf-8") as f:
                    self.codebase_context = json.load(f)
            except Exception as e:
                print(f"Error loading index: {e}")
                self.codebase_context = None

    def save_context(self):
        """Save the codebase context to disk."""
        if self.codebase_context:
            try:
                with open(self.index_file, "w", encoding="utf-8") as f:
                    json.dump(self.codebase_context, f, indent=2)
            except Exception as e:
                print(f"Error saving index: {e}")

    def set_context(self, context: Dict[str, Any]):
        """Set the codebase context for queries."""
        self.codebase_context = context
        self.save_context()

    def format_context(self) -> str:
        """Format the codebase context for Gemini."""
        if not self.codebase_context:
            return ""

        context_parts = []
        for file_path, details in self.codebase_context.items():
            defs = details["definitions"]
            context_parts.append(
                f"File: {file_path}\n"
                f"Classes: {[c['name'] for c in defs['classes']]}\n"
                f"Functions: {[f['name'] for f in defs['functions']]}\n"
                f"Imports: {defs['imports']}\n"
            )
        return "\n\n".join(context_parts)

    def query(self, query: str) -> Optional[str]:
        """Process a query about the codebase."""
        if not self.codebase_context:
            return (
                "Error: No codebase context available. Please index the codebase first."
            )

        prompt = f"""
        Given the following codebase structure:
        {self.format_context()}
        
        Query: {query}
        
        Please provide a detailed and accurate answer based on the codebase structure above.
        """
        return self.gemini_client.query(prompt)

Ausgabe:

import os
import json
import typer
from pathlib import Path
from typing import Optional
from indexer.code_parser import parse_codebase
from query_engine.query_processor import QueryProcessor

Ausgabe:

Wenn alles richtig gemacht wird, erhalten Sie diese Ausgänge in Ihrem Terminal. Sie können es mit Ihren Python -Code -Dateien versuchen und mir im Kommentarbereich mitteilen, was Ihre Ausgabe ist. Danke, dass du bei mir geblieben bist.

zukünftige Entwicklung

Dies ist ein Prototyp des Foundation -Systems, der mit vielen interessanten Merkmalen erweitert werden kann, wie z. B.

• Sie können sich in IDE -Plugins für eine nahtlose Code -Exploration integrieren.
• AI-gesteuerte automatisierte Debugging-System (ich arbeite daran).
• Unterstützung für viele beliebte Sprachen wie JavaScript, Java, Typecripts, Rost.
• Echtzeit-Codeanalyse und LLM-Stromversorgungsvorschläge für Verbesserungen.
• automatisierte Dokumentation mit Gemini oder Lama3.
• Lokale LLM-Integration für die Exploration von On-Device-Code, Features Addition.

Schlussfolgerung

Der Codebasis -Explorer hilft Ihnen, die praktische Anwendung von KI in Softwareentwicklungstools zu verstehen. Durch die Kombination der traditionellen statischen Analyse mit modernen KI -Funktionen haben wir ein Tool erstellt, das die Codebasis -Erkundung intuitiver und effizienter macht. Dieser Ansatz zeigt, wie KI Entwickler -Workflows erhöhen kann, ohne vorhandene Tools zu ersetzen, und eine neue Ebene des Verständnisses und der Zugänglichkeit für komplexe Codebasen bietet.

Der gesamte in diesem Artikel verwendete Code ist hier.

Key Takeaways

• Strukturcode Parsing ist die imortanteste Technik für die Codeanalyse.
• Codebase Explorer vereinfacht die Code -Navigation und ermöglicht es Entwicklern, komplexe Codestrukturen schnell zu verstehen und zu verwalten.
• Codebasis Explorer verbessert die Debugging -Effizienz und bietet Tools zur Analyse von Abhängigkeiten und identifizieren Probleme schneller.
• Gemini kann das Codeverständnis in Kombination mit herkömmlicher statischer Analyse erheblich verbessern.
• CLI -Tools können eine leistungsstarke Schnittstelle für die LLM -unterstützte Code -Exploration liefern.

häufig gestellte Fragen

q 1. Wie handelt das Tool mit großer Codebasis?

a. Das Tool verwendet ein persistierendes Indexierungssystem, das die Codebasisstruktur analysiert und speichert, um effiziente Abfragen zu ermöglichen, ohne den Code jedes Mal neu zu analysieren. Der Index wird nur aktualisiert, wenn sich die Codebasis ändert.

q 2. Kann das Tool offline funktionieren?

a. Das Code -Analyse und das Indexmanagement können offline funktionieren, aber die Abfrage der Codebasis mithilfe von Gemini API muss eine Internetverbindung abfragen, um mit den externen Servern zu kommunizieren. Wir können Ollama in die Tools integrieren, mit denen das LLM- oder SLM-Modell von On-Device-LLM oder LLAMA3 oder PHI-3 zum Abfragen der Codebasis verwendet werden kann.

q 3. Wie genau sind die LLM -erzeugten Antworten?

a. Die Genauigkeit hängt sowohl von der Qualität des analysierten Codekontexts als auch von den Fähigkeiten des Gemini -Modells ab. Die Tools liefern strukturierte Codeinformationen für das KI -Modell und verbessern die Reaktionsgenauigkeit. Benutzer sollten jedoch weiterhin kritische Informationen über herkömmliche Weise überprüfen.

Die in diesem Artikel gezeigten Medien sind nicht im Besitz von Analytics Vidhya und wird nach Ermessen des Autors verwendet.

Das obige ist der detaillierte Inhalt vonErstellen eines Codebasis-Explorers mit Gemini-2,0 von Google 039;. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!