auto rust

Autorost

auto-rust ist ein prozedurales Rust-Makro, das die Leistungsfähigkeit von Large Language Models (LLMs) nutzt, um Code zur Kompilierungszeit zu generieren. Schreiben Sie eine Funktionssignatur, fügen Sie einen Dokumentkommentar hinzu, der die gewünschte Funktionalität beschreibt, und lassen Sie auto-rust die Implementierungsdetails ausfüllen!

️ Warnung

Auto-Rust befindet sich derzeit in der Entwicklung und ist noch nicht für den Produktionseinsatz geeignet. Sie können es zwar gerne ausprobieren und Feedback geben, wir weisen jedoch darauf hin, dass die Implementierung möglicherweise unvollständig ist und möglicherweise nicht wie vorgesehen funktioniert.

Merkmale

• KI-gestützte Codegenerierung: Nutzen Sie die Fähigkeiten von LLMs, um Rust-Funktionskörper basierend auf Ihren Spezifikationen zu generieren.
• Integration zur Kompilierungszeit: Integrieren Sie die Codegenerierung nahtlos in Ihre Rust-Projekte mit unserem benutzerfreundlichen prozeduralen Makro.
• Kontextbewusste Generierung: Auto-Rust berücksichtigt Ihre Funktionssignatur, Dokumentkommentare und etwas Code in Ihrem Projekt, um kontextrelevante Implementierungen zu generieren.
• Integriertes Caching: Auto-Rust speichert erfolgreiche Ergebnisse der Codegenerierung zwischen, um Ihren Entwicklungsworkflow zu beschleunigen. Vermeiden Sie unnötige LLM-Aufrufe und reduzieren Sie die Kompilierungszeiten!

Erste Schritte

1. Installation

Fügen Sie auto-rust als Abhängigkeit in Ihrer Cargo.toml Datei hinzu:

[ dependencies ]
auto-rust = " 0.1.4 "

2. API-Schlüssel

Auto-Rust erfordert einen OpenAI-API-Schlüssel. Erstellen Sie eine .env Datei im Stammverzeichnis Ihres Projekts und fügen Sie Ihren Schlüssel hinzu:

OPENAI_API_KEY= < your-openai-api-key >

3. Nutzung

Kommentieren Sie Ihre Funktion mit dem Attribut #[llm_tool] und geben Sie einen klaren Dokumentkommentar an, der das gewünschte Verhalten erklärt:

 use auto_rust :: llm_tool ;

# [ llm_tool ]
# [ handler ]
/// The response will be an HTML layout with the name and the number of letters in the name.
/// Ensure to return a content type of text/html.
fn hello ( Path ( name ) : Path < String > ) -> impl IntoResponse {
    todo ! ( )
}

Live-Neuladen mit live -Argument

Um das Live-Neuladen für eine nahtlose Entwicklung zu ermöglichen, verwenden Sie das live Argument für das Makro llm_tool .

 # [ llm_tool ( live ) ] 

Durch die Aktivierung live -Neuladens wird Auto-Rust gezwungen, seinen Caching-Mechanismus zu umgehen. Bei jeder Kompilierung wird eine Anfrage an das LLM gesendet, um sicherzustellen, dass Sie immer die aktuellste Codegenerierung basierend auf Ihrer Funktionssignatur, Dokumentkommentaren und dem aktuellen Codebasiskontext erhalten.

So funktioniert Caching

Auto-Rust implementiert einen einfachen Caching-Mechanismus. Jedes Mal, wenn Code für eine Funktion generiert wird:

• Es erstellt einen Hash basierend auf der Funktionssignatur, Dokumentkommentaren und dem relevanten Codekontext.
• Dieser Hash wird zum Speichern des vom LLM generierten Codes verwendet.
• Bei nachfolgenden Kompilierungen prüft Auto-Rust zunächst, ob für den angegebenen Hash ein zwischengespeichertes Ergebnis vorhanden ist. Wenn es gefunden wird, verwendet es direkt den zwischengespeicherten Code und verhindert so unnötige LLM-Aufrufe.

Verwenden Sie das live -Argument, wenn Sie dem Empfang der aktuellsten Codegeneration vom LLM Priorität einräumen möchten, auch wenn dies zu leicht längeren Kompilierungszeiten führt.

Beispiel

 use auto_rust :: llm_tool ;
use poem :: {
    get , handler , listener :: TcpListener , middleware :: Tracing , web :: Path , EndpointExt , IntoResponse ,
    Route , Server ,
} ;

# [ llm_tool ]
# [ handler ]
/// The response will be an html layout with the name and the number of letters in the name.
/// Ensure to return a content type of text/html.
fn hello ( Path ( name ) : Path < String > ) -> impl IntoResponse {
    todo ! ( )
}

# [ tokio :: main ]
async fn main ( ) -> Result < ( ) , std :: io :: Error > {
    // ...
}

Generierter Code:

 # [ handler ]
/// The response will be an html layout with the name and the number of letters in the name.
/// Ensure to return a content type of text/html.
fn hello ( Path ( name ) : Path < String > ) -> impl IntoResponse {
    let response_html = format ! (
    r#"
<!DOCTYPE html>
<html>
<head>
    <title>Hello, {name}!</title>
</head>
<body>
    <h1>Hello, {name}!</h1>
    <p>The length of your name is {len} letters.</p>
</body>
</html>
"# ,
    name = name,
    len = name.len ( )
) ;

poem :: Response :: builder ( )
    . header ( "Content-Type" , "text/html; charset=utf-8" )
    . body ( response_html )
} 

Erklärung für Entwickler

Auto-Rust nutzt das leistungsstarke prozedurale Makrosystem von Rust, um Code zur Kompilierungszeit einzufügen. Wenn Sie das Makro #[llm_tool] verwenden:

1. Parsen: Das Makro analysiert die Signatur der mit Anmerkungen versehenen Funktion, einschließlich ihres Namens, ihrer Argumente, ihres Rückgabetyps und aller Dokumentkommentare.

2. Kontextextraktion: Sie extrahiert den Code innerhalb Ihres Projekts und stellt dem LLM einen Kontext bereit, damit er den umgebenden Code und das Projekt besser verstehen kann.

3. Prompt Engineering: Es erstellt eine Eingabeaufforderung, die die extrahierten Informationen enthält. Diese Eingabeaufforderung wurde sorgfältig entwickelt, um den LLM bei der Generierung einer relevanten und korrekten Rust-Funktionsimplementierung zu unterstützen.

4. LLM-Interaktion: Es sendet die generierte Eingabeaufforderung an eine LLM-API.

5. Code-Einfügung: Die Antwort des LLM, die den generierten Rust-Code enthält, wird direkt in Ihre Codebasis eingefügt und ersetzt den Platzhalter todo!() .

Einschränkungen

• LLM-Nichtdeterminismus: Die LLM-Ausgabe kann variieren. Möglicherweise müssen Sie experimentieren und iterieren, um die gewünschten Ergebnisse zu erzielen.
• Eingeschränkter Kontext: Derzeit basiert der Kontext von Auto-Rust hauptsächlich auf Ihrer Funktionssignatur und Ihren Dokumentkommentaren. Das Bewusstsein für die umfassendere Projektstruktur ist begrenzt.
• Abhängigkeitsmanagement: Auto-Rust fügt dem generierten Code nicht automatisch use für neu eingeführte Abhängigkeiten hinzu.

Mitwirken

Wir freuen uns über Beiträge aus der Rust-Community! Wenn Sie auf Probleme stoßen, Vorschläge haben oder zur Entwicklung von auto-rust beitragen möchten, können Sie gerne ein Problem eröffnen oder eine Pull-Anfrage einreichen.

Lizenz

Dieses Projekt ist unter den MIT- und Apache-2.0-Lizenzen lizenziert.