gollm
1.0.0
gollm ist ein Go -Paket, mit dem Sie Ihre eigenen AI Golems erstellen können. So wie der mystische Golem der Legende mit heiligen Worten zum Leben erweckt wurde, ermächtigt gollm Sie, Ihren KI -Kreationen mit der Kraft großer Sprachmodelle (LLMs) das Leben einzuhauchen. Dieses Paket vereinfacht und optimiert die Interaktionen mit verschiedenen LLM -Anbietern und bietet KI -Ingenieuren und Entwicklern eine einheitliche, flexible und leistungsstarke Oberfläche, um ihre eigenen digitalen Diener zu erstellen.
Dokumentation
ChainOfThought für komplexe Argumentationsaufgaben. gollm kann eine breite Palette von KI-angetriebenen Aufgaben erledigen, darunter:
ChainOfThought um komplexe Probleme Schritt für Schritt zu analysieren.go get github.com/teilomillet/gollm package main
import (
"context"
"fmt"
"log"
"os"
"github.com/teilomillet/gollm"
)
func main () {
// Load API key from environment variable
apiKey := os . Getenv ( "OPENAI_API_KEY" )
if apiKey == "" {
log . Fatalf ( "OPENAI_API_KEY environment variable is not set" )
}
// Create a new LLM instance with custom configuration
llm , err := gollm . NewLLM (
gollm . SetProvider ( "openai" ),
gollm . SetModel ( "gpt-4o-mini" ),
gollm . SetAPIKey ( apiKey ),
gollm . SetMaxTokens ( 200 ),
gollm . SetMaxRetries ( 3 ),
gollm . SetRetryDelay ( time . Second * 2 ),
gollm . SetLogLevel ( gollm . LogLevelInfo ),
)
if err != nil {
log . Fatalf ( "Failed to create LLM: %v" , err )
}
ctx := context . Background ()
// Create a basic prompt
prompt := gollm . NewPrompt ( "Explain the concept of 'recursion' in programming." )
// Generate a response
response , err := llm . Generate ( ctx , prompt )
if err != nil {
log . Fatalf ( "Failed to generate text: %v" , err )
}
fmt . Printf ( "Response: n %s n " , response )
}
## Quick Reference
Here 's a quick reference guide for the most commonly used functions and options in the `gollm` package :
### LLM Creation and Configuration
`` `go
llm, err := gollm.NewLLM(
gollm.SetProvider("openai"),
gollm.SetModel("gpt-4"),
gollm.SetAPIKey("your-api-key"),
gollm.SetMaxTokens(100),
gollm.SetTemperature(0.7),
gollm.SetMemory(4096),
) prompt := gollm . NewPrompt ( "Your prompt text here" ,
gollm . WithContext ( "Additional context" ),
gollm . WithDirectives ( "Be concise" , "Use examples" ),
gollm . WithOutput ( "Expected output format" ),
gollm . WithMaxLength ( 300 ),
) response , err := llm . Generate ( ctx , prompt ) response , err := tools . ChainOfThought ( ctx , llm , "Your question here" ) optimizer := optimizer . NewPromptOptimizer ( llm , initialPrompt , taskDescription ,
optimizer . WithCustomMetrics ( /* custom metrics */ ),
optimizer . WithRatingSystem ( "numerical" ),
optimizer . WithThreshold ( 0.8 ),
)
optimizedPrompt , err := optimizer . OptimizePrompt ( ctx ) results , err := tools . CompareModels ( ctx , promptText , validateFunc , configs ... ) Das gollm -Paket bietet eine Reihe fortschrittlicher Funktionen, um Ihre KI -Anwendungen zu verbessern:
Erstellen Sie anspruchsvolle Eingabeaufforderungen mit mehreren Komponenten:
prompt := gollm . NewPrompt ( "Explain the concept of recursion in programming." ,
gollm . WithContext ( "The audience is beginner programmers." ),
gollm . WithDirectives (
"Use simple language and avoid jargon." ,
"Provide a practical example." ,
"Explain potential pitfalls and how to avoid them." ,
),
gollm . WithOutput ( "Structure your response with sections: Definition, Example, Pitfalls, Best Practices." ),
gollm . WithMaxLength ( 300 ),
)
response , err := llm . Generate ( ctx , prompt )
if err != nil {
log . Fatalf ( "Failed to generate explanation: %v" , err )
}
fmt . Printf ( "Explanation of Recursion: n %s n " , response ) Verwenden Sie die Kette ChainOfThought für Schritt-für-Schritt-Argumentation für die Kette ausmacht, für Schritt für Schritt:
question := "What is the result of 15 * 7 + 22?"
response , err := tools . ChainOfThought ( ctx , llm , question )
if err != nil {
log . Fatalf ( "Failed to perform chain of thought: %v" , err )
}
fmt . Printf ( "Chain of Thought: n %s n " , response )Laden Sie Beispiele direkt aus Dateien:
examples , err := utils . ReadExamplesFromFile ( "examples.txt" )
if err != nil {
log . Fatalf ( "Failed to read examples: %v" , err )
}
prompt := gollm . NewPrompt ( "Generate a similar example:" ,
gollm . WithExamples ( examples ... ),
)
response , err := llm . Generate ( ctx , prompt )
if err != nil {
log . Fatalf ( "Failed to generate example: %v" , err )
}
fmt . Printf ( "Generated Example: n %s n " , response )Erstellen Sie wiederverwendbare schnelle Vorlagen für die konsistente Eingabeaufforderungserzeugung:
// Create a new prompt template
template := gollm . NewPromptTemplate (
"AnalysisTemplate" ,
"A template for analyzing topics" ,
"Provide a comprehensive analysis of {{.Topic}}. Consider the following aspects: n " +
"1. Historical context n " +
"2. Current relevance n " +
"3. Future implications" ,
gollm . WithPromptOptions (
gollm . WithDirectives (
"Use clear and concise language" ,
"Provide specific examples where appropriate" ,
),
gollm . WithOutput ( "Structure your analysis with clear headings for each aspect." ),
),
)
// Use the template to create a prompt
data := map [ string ] interface {}{
"Topic" : "artificial intelligence in healthcare" ,
}
prompt , err := template . Execute ( data )
if err != nil {
log . Fatalf ( "Failed to execute template: %v" , err )
}
// Generate a response using the created prompt
response , err := llm . Generate ( ctx , prompt )
if err != nil {
log . Fatalf ( "Failed to generate response: %v" , err )
}
fmt . Printf ( "Analysis: n %s n " , response )Stellen Sie sicher, dass Ihre LLM -Ausgänge in einem gültigen JSON -Format sind:
prompt := gollm . NewPrompt ( "Analyze the pros and cons of remote work." ,
gollm . WithOutput ( "Respond in JSON format with 'topic', 'pros', 'cons', and 'conclusion' fields." ),
)
response , err := llm . Generate ( ctx , prompt , gollm . WithJSONSchemaValidation ())
if err != nil {
log . Fatalf ( "Failed to generate valid analysis: %v" , err )
}
var result AnalysisResult
if err := json . Unmarshal ([] byte ( response ), & result ); err != nil {
log . Fatalf ( "Failed to parse response: %v" , err )
}
fmt . Printf ( "Analysis: %+v n " , result ) Verwenden Sie den PromptOptimizer , Ihre Eingabeaufforderungen automatisch zu verfeinern und zu verbessern:
initialPrompt := gollm . NewPrompt ( "Write a short story about a robot learning to love." )
taskDescription := "Generate a compelling short story that explores the theme of artificial intelligence developing emotions."
optimizerInstance := optimizer . NewPromptOptimizer (
llm ,
initialPrompt ,
taskDescription ,
optimizer . WithCustomMetrics (
optimizer. Metric { Name : "Creativity" , Description : "How original and imaginative the story is" },
optimizer. Metric { Name : "Emotional Impact" , Description : "How well the story evokes feelings in the reader" },
),
optimizer . WithRatingSystem ( "numerical" ),
optimizer . WithThreshold ( 0.8 ),
optimizer . WithVerbose (),
)
optimizedPrompt , err := optimizerInstance . OptimizePrompt ( ctx )
if err != nil {
log . Fatalf ( "Optimization failed: %v" , err )
}
fmt . Printf ( "Optimized Prompt: %s n " , optimizedPrompt . Input )Vergleichen Sie Antworten aus verschiedenen LLM -Anbietern oder Modellen:
configs := [] * gollm. Config {
{
Provider : "openai" ,
Model : "gpt-4o-mini" ,
APIKey : os . Getenv ( "OPENAI_API_KEY" ),
MaxTokens : 500 ,
},
{
Provider : "anthropic" ,
Model : "claude-3-5-sonnet-20240620" ,
APIKey : os . Getenv ( "ANTHROPIC_API_KEY" ),
MaxTokens : 500 ,
},
{
Provider : "groq" ,
Model : "llama-3.1-70b-versatile" ,
APIKey : os . Getenv ( "GROQ_API_KEY" ),
MaxTokens : 500 ,
},
}
promptText := "Tell me a joke about programming. Respond in JSON format with 'setup' and 'punchline' fields."
validateJoke := func ( joke map [ string ] interface {}) error {
if joke [ "setup" ] == "" || joke [ "punchline" ] == "" {
return fmt . Errorf ( "joke must have both a setup and a punchline" )
}
return nil
}
results , err := tools . CompareModels ( context . Background (), promptText , validateJoke , configs ... )
if err != nil {
log . Fatalf ( "Error comparing models: %v" , err )
}
fmt . Println ( tools . AnalyzeComparisonResults ( results ))Aktivieren Sie das Gedächtnis, um den Kontext über mehrere Interaktionen hinweg aufrechtzuerhalten:
llm , err := gollm . NewLLM (
gollm . SetProvider ( "openai" ),
gollm . SetModel ( "gpt-3.5-turbo" ),
gollm . SetAPIKey ( os . Getenv ( "OPENAI_API_KEY" )),
gollm . SetMemory ( 4096 ), // Enable memory with a 4096 token limit
)
if err != nil {
log . Fatalf ( "Failed to create LLM: %v" , err )
}
ctx := context . Background ()
// First interaction
prompt1 := gollm . NewPrompt ( "What's the capital of France?" )
response1 , err := llm . Generate ( ctx , prompt1 )
if err != nil {
log . Fatalf ( "Failed to generate response: %v" , err )
}
fmt . Printf ( "Response 1: %s n " , response1 )
// Second interaction, referencing the first
prompt2 := gollm . NewPrompt ( "What's the population of that city?" )
response2 , err := llm . Generate ( ctx , prompt2 )
if err != nil {
log . Fatalf ( "Failed to generate response: %v" , err )
}
fmt . Printf ( "Response 2: %s n " , response2 )Schnelltechnik :
NewPrompt() mit Optionen wie WithContext() , WithDirectives() und WithOutput() um gut strukturierte Eingabeaufforderungen zu erstellen. prompt := gollm . NewPrompt ( "Your main prompt here" ,
gollm . WithContext ( "Provide relevant context" ),
gollm . WithDirectives ( "Be concise" , "Use examples" ),
gollm . WithOutput ( "Specify expected output format" ),
)Verwenden Sie schnelle Vorlagen :
PromptTemplate für die konsistente Eingabeaufforderung an. template := gollm . NewPromptTemplate (
"CustomTemplate" ,
"A template for custom prompts" ,
"Generate a {{.Type}} about {{.Topic}}" ,
gollm . WithPromptOptions (
gollm . WithDirectives ( "Be creative" , "Use vivid language" ),
gollm . WithOutput ( "Your {{.Type}}:" ),
),
)Nutzen Sie vorgefertigte Funktionen :
ChainOfThought() für komplexe Argumentationsaufgaben. response , err := tools . ChainOfThought ( ctx , llm , "Your complex question here" )Arbeiten Sie mit Beispielen :
ReadExamplesFromFile() um Beispiele aus Dateien für konsistente Ausgänge zu laden. examples , err := utils . ReadExamplesFromFile ( "examples.txt" )
if err != nil {
log . Fatalf ( "Failed to read examples: %v" , err )
}Strukturierte Ausgabe implementieren :
WithJSONSchemaValidation() um gültige JSON -Ausgaben zu gewährleisten. response , err := llm . Generate ( ctx , prompt , gollm . WithJSONSchemaValidation ())Eingabeaufforderungen optimieren :
PromptOptimizer , um die Eingabeaufforderungen automatisch zu verfeinern. optimizer := optimizer . NewPromptOptimizer ( llm , initialPrompt , taskDescription ,
optimizer . WithCustomMetrics (
optimizer. Metric { Name : "Relevance" , Description : "How relevant the response is to the task" },
),
optimizer . WithRatingSystem ( "numerical" ),
optimizer . WithThreshold ( 0.8 ),
)Vergleichen Sie Modelldarstellungen :
CompareModels() um verschiedene Modelle oder Anbieter zu bewerten. results , err := tools . CompareModels ( ctx , promptText , validateFunc , configs ... )Implementieren Sie den Speicher für kontextbezogene Interaktionen :
llm , err := gollm . NewLLM (
gollm . SetProvider ( "openai" ),
gollm . SetModel ( "gpt-3.5-turbo" ),
gollm . SetMemory ( 4096 ),
)Fehlerbehebung und -verkehr :
llm , err := gollm . NewLLM (
gollm . SetMaxRetries ( 3 ),
gollm . SetRetryDelay ( time . Second * 2 ),
)Sicherung der API -Schlüsselhandhabung :
llm , err := gollm . NewLLM (
gollm . SetAPIKey ( os . Getenv ( "OPENAI_API_KEY" )),
)Weitere Verwendungsbeispiele finden Sie in unserem Beispiel -Verzeichnis, darunter:
gollm ist aktiv aufrechterhalten und unter kontinuierlicher Entwicklung. Mit dem jüngsten Refactoring haben wir die Codebasis optimiert, um sie für neue Mitwirkende einfacher und zugänglicher zu machen. Wir begrüßen Beiträge und Feedback der Community.
gollm basiert auf einer Philosophie des pragmatischen Minimalismus und der zukunftsorientierten Einfachheit:
Erstellen Sie, was notwendig ist : Wir fügen Funktionen hinzu, während sie benötigt werden, um eine spekulative Entwicklung zu vermeiden.
Einfachheit zuerst : Ergänzungen sollten unkompliziert sein, während sie ihren Zweck erfüllen.
Zukunftskompatible : Wir überlegen, wie sich die aktuellen Veränderungen auf die zukünftige Entwicklung auswirken könnten.
Lesbarkeitszählungen : Code sollte klar und selbsterklärend sein.
Modulares Design : Jede Komponente sollte eine Sache gut machen.
Wir begrüßen Beiträge, die mit unserer Philosophie übereinstimmen! Egal, ob Sie einen Fehler beheben, die Dokumentation verbessern oder neue Funktionen vorschlagen, Ihre Bemühungen werden geschätzt.
Um loszulegen:
Vielen Dank, dass Sie gollm besser gemacht haben!
Dieses Projekt ist unter der Apache -Lizenz 2.0 lizenziert. Weitere Informationen finden Sie in der Lizenzdatei.
