gollm
1.0.0
gollm adalah paket GO yang dirancang untuk membantu Anda membangun golem AI Anda sendiri. Sama seperti golem mistis legenda dihidupkan dengan kata -kata suci, gollm memberdayakan Anda untuk menghembuskan kehidupan ke dalam kreasi AI Anda menggunakan kekuatan model bahasa besar (LLM). Paket ini menyederhanakan dan merampingkan interaksi dengan berbagai penyedia LLM, menawarkan antarmuka yang bersatu, fleksibel, dan kuat bagi para insinyur dan pengembang untuk membuat pelayan digital mereka sendiri.
Dokumentasi
ChainOfThought untuk tugas penalaran yang kompleks. gollm dapat menangani berbagai tugas bertenaga AI, termasuk:
ChainOfThought untuk menganalisis masalah kompleks langkah demi langkah.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 ... ) Paket gollm menawarkan berbagai fitur canggih untuk meningkatkan aplikasi AI Anda:
Buat petunjuk canggih dengan banyak komponen:
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 ) Gunakan fungsi ChainOfThought untuk penalaran langkah demi langkah:
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 )Muat contoh langsung dari file:
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 )Buat templat prompt yang dapat digunakan kembali untuk pembuatan cepat yang konsisten:
// 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 )Pastikan output LLM Anda berada dalam format JSON yang valid:
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 ) Gunakan PromptOptimizer untuk secara otomatis memperbaiki dan meningkatkan petunjuk Anda:
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 )Bandingkan tanggapan dari berbagai penyedia atau model LLM:
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 ))Aktifkan memori untuk mempertahankan konteks di berbagai interaksi:
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 )Teknik cepat :
NewPrompt() dengan opsi seperti WithContext() , WithDirectives() , dan WithOutput() untuk membuat prompt yang terstruktur dengan baik. prompt := gollm . NewPrompt ( "Your main prompt here" ,
gollm . WithContext ( "Provide relevant context" ),
gollm . WithDirectives ( "Be concise" , "Use examples" ),
gollm . WithOutput ( "Specify expected output format" ),
)Memanfaatkan template cepat :
PromptTemplate . 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}}:" ),
),
)Leverage Fungsi Pra-Built :
ChainOfThought() untuk tugas penalaran yang kompleks. response , err := tools . ChainOfThought ( ctx , llm , "Your complex question here" )Bekerja dengan contoh :
ReadExamplesFromFile() untuk memuat contoh dari file untuk output yang konsisten. examples , err := utils . ReadExamplesFromFile ( "examples.txt" )
if err != nil {
log . Fatalf ( "Failed to read examples: %v" , err )
}Menerapkan output terstruktur :
WithJSONSchemaValidation() untuk memastikan output JSON yang valid. response , err := llm . Generate ( ctx , prompt , gollm . WithJSONSchemaValidation ())Mengoptimalkan petunjuk :
PromptOptimizer untuk memperbaiki permintaan secara otomatis. 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 ),
)Bandingkan model kinerja :
CompareModels() untuk mengevaluasi berbagai model atau penyedia. results , err := tools . CompareModels ( ctx , promptText , validateFunc , configs ... )Menerapkan memori untuk interaksi kontekstual :
llm , err := gollm . NewLLM (
gollm . SetProvider ( "openai" ),
gollm . SetModel ( "gpt-3.5-turbo" ),
gollm . SetMemory ( 4096 ),
)Penanganan kesalahan dan coba lagi :
llm , err := gollm . NewLLM (
gollm . SetMaxRetries ( 3 ),
gollm . SetRetryDelay ( time . Second * 2 ),
)Penanganan kunci API yang aman :
llm , err := gollm . NewLLM (
gollm . SetAPIKey ( os . Getenv ( "OPENAI_API_KEY" )),
)Lihatlah Direktori Contoh kami untuk contoh penggunaan lebih lanjut, termasuk:
gollm dipertahankan secara aktif dan di bawah pengembangan berkelanjutan. Dengan refactoring baru -baru ini, kami telah merampingkan basis kode untuk membuatnya lebih sederhana dan lebih mudah diakses oleh kontributor baru. Kami menyambut kontribusi dan umpan balik dari komunitas.
gollm dibangun di atas filosofi minimalis pragmatis dan kesederhanaan yang berpikiran maju:
Bangun apa yang diperlukan : kami menambahkan fitur saat dibutuhkan, menghindari pengembangan spekulatif.
Kesederhanaan Pertama : Penambahan harus langsung saat memenuhi tujuan mereka.
Compatible di masa depan : Kami mempertimbangkan bagaimana perubahan saat ini dapat memengaruhi pengembangan di masa depan.
Hitungan keterbacaan : Kode harus jelas dan jelas.
Desain Modular : Setiap komponen harus melakukan satu hal dengan baik.
Kami menyambut kontribusi yang selaras dengan filosofi kami! Apakah Anda memperbaiki bug, meningkatkan dokumentasi, atau mengusulkan fitur baru, upaya Anda dihargai.
Untuk memulai:
Terima kasih telah membantu membuat gollm lebih baik!
Proyek ini dilisensikan di bawah Lisensi Apache 2.0 - lihat file lisensi untuk detailnya.
