Página Inicial>Relacionado com a programação>Outro código-fonte
Baixar

Gollm - vá grande modelo de idioma

Gophers construindo um robô por Renee French

gollm é um pacote Go projetado para ajudá -lo a construir seus próprios Golems da AI. Assim como o Mystical Golem of Legend foi trazido à vida com palavras sagradas, gollm o capacita a dar vida às suas criações de IA usando o poder de grandes modelos de linguagem (LLMS). Este pacote simplifica e simplifica as interações com vários provedores de LLM, oferecendo uma interface unificada, flexível e poderosa para engenheiros e desenvolvedores de IA criarem seus próprios servos digitais.

Documentação

Índice

  • Principais recursos
  • Aplicações do mundo real
  • Instalação
  • Início rápido
    • Uso básico
  • Referência rápida
    • Criação e configuração de LLM
    • Criação imediata
    • Gerar resposta
    • Cadeia de pensamento
    • Otimização imediata
    • Comparação de modelos
  • Uso avançado
    • Engenharia rápida
    • Funções pré-construídas (cadeia de pensamento)
    • Trabalhando com exemplos
    • Modelos rápidos
    • Saída estruturada (validação de saída JSON)
    • Otimizador imediato
    • Comparação de modelos
    • Retenção de memória
  • Práticas recomendadas
  • Exemplos e tutoriais
  • Status do projeto
  • Filosofia
  • Contribuindo
  • Licença

Principais recursos

  • API unificado para vários fornecedores de LLM: interaja perfeitamente com vários fornecedores, incluindo OpenAI, Antrópico, Groq e Ollama. Alterne facilmente entre modelos como GPT-4, Claude e Llama-3.1.
  • Comutação fácil de provedores e modelos: configure provedores e modelos preferidos com opções simples.
  • Opções de configuração flexíveis: personalize o uso de variáveis ​​de ambiente, configuração baseada em código ou arquivos de configuração.
  • Engenharia rápida avançada: crie instruções sofisticadas para orientar as respostas da sua IA de maneira eficaz.
  • Otimizador rápido: refine e melhore automaticamente seus avisos para obter melhores resultados, com suporte para métricas personalizadas e diferentes sistemas de classificação.
  • Retenção de memória: mantenha o contexto em várias interações para conversas mais coerentes.
  • Saída e validação estruturada: Verifique se as saídas são consistentes e confiáveis ​​com a geração e validação de esquema JSON.
  • Ferramentas de comparação de provedores: o desempenho do teste em diferentes provedores e modelos de LLM para a mesma tarefa.
  • Funções de AI de alto nível: use funções pré-construídas como ChainOfThought para tarefas complexas de raciocínio.
  • Manuseio e tentativas de erro robustos: mecanismos de repetição internos para lidar com limites de taxa de API e erros transitórios.
  • Arquitetura extensível: expandir facilmente o suporte para novos provedores e recursos de LLM.

Aplicações do mundo real

gollm pode lidar com uma ampla gama de tarefas movidas a IA, incluindo:

  • Fluxos de trabalho de criação de conteúdo: gerar resumos de pesquisa, idéias de artigo e parágrafos refinados.
  • Tarefas de raciocínio complexas: use a função ChainOfThought para analisar problemas complexos passo a passo.
  • Geração de dados estruturados: Crie e valida estruturas de dados complexas com esquemas JSON personalizáveis.
  • Análise de desempenho do modelo: compare o desempenho de diferentes modelos para tarefas específicas.
  • Otimização imediata: melhore automaticamente os avisos para várias tarefas.
  • Mistura de agentes: Combine respostas de vários fornecedores de LLM.

Instalação 

go get github.com/teilomillet/gollm

Início rápido

Uso básico 

 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),
)

Criação imediata 

 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 ),
)

Gerar resposta 

 response , err := llm . Generate ( ctx , prompt )

Cadeia de pensamento 

 response , err := tools . ChainOfThought ( ctx , llm , "Your question here" )

Otimização imediata 

 optimizer := optimizer . NewPromptOptimizer ( llm , initialPrompt , taskDescription ,
    optimizer . WithCustomMetrics ( /* custom metrics */ ),
    optimizer . WithRatingSystem ( "numerical" ),
    optimizer . WithThreshold ( 0.8 ),
)
optimizedPrompt , err := optimizer . OptimizePrompt ( ctx )

Comparação de modelos 

 results , err := tools . CompareModels ( ctx , promptText , validateFunc , configs ... )

Uso avançado

O pacote gollm oferece uma gama de recursos avançados para aprimorar seus aplicativos de IA:

Engenharia rápida

Crie instruções sofisticadas com vários componentes: 

 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 )

Funções pré-construídas (cadeia de pensamento)

Use a função ChainOfThought para o raciocínio passo a passo: 

 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 )

Trabalhando com exemplos

Carregue exemplos diretamente dos arquivos: 

 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 )

Modelos rápidos

Crie modelos de prompt reutilizáveis ​​para uma geração de prompt consistente: 

 // 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 )

Saída estruturada (validação de saída JSON)

Verifique se suas saídas LLM estão em um formato JSON válido: 

 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 )

Otimizador imediato

Use o PromptOptimizer para refinar e melhorar automaticamente seus avisos: 

 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 )

Comparação de modelos

Compare as respostas de diferentes fornecedores ou modelos de 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 ))

Retenção de memória

Habilite a memória para manter o contexto em várias interações: 

 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 )

Práticas recomendadas

  1. Engenharia rápida :

    • Use NewPrompt() com opções como WithContext() , WithDirectives() e WithOutput() para criar prompts bem estruturados.
    • Exemplo: 
       prompt := gollm . NewPrompt ( "Your main prompt here" ,
    gollm . WithContext ( "Provide relevant context" ),
    gollm . WithDirectives ( "Be concise" , "Use examples" ),
    gollm . WithOutput ( "Specify expected output format" ),
)

  2. Utilize modelos rápidos :

    • Para uma geração de prompt consistente, crie e use objetos PromptTemplate .
    • Exemplo: 
       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}}:" ),
    ),
)

  3. Aproveite as funções pré-construídas :

    • Uso fornecido funções como ChainOfThought() para tarefas complexas de raciocínio.
    • Exemplo: 
       response , err := tools . ChainOfThought ( ctx , llm , "Your complex question here" )

  4. Trabalhe com exemplos :

    • Use ReadExamplesFromFile() para carregar exemplos de arquivos para saídas consistentes.
    • Exemplo: 
       examples , err := utils . ReadExamplesFromFile ( "examples.txt" )
if err != nil {
    log . Fatalf ( "Failed to read examples: %v" , err )
}

  5. Implementar saída estruturada :

    • Use WithJSONSchemaValidation() para garantir saídas JSON válidas.
    • Exemplo: 
       response , err := llm . Generate ( ctx , prompt , gollm . WithJSONSchemaValidation ())

  6. Otimize os prompts :

    • Utilize PromptOptimizer para refinar os avisos automaticamente.
    • Exemplo: 
       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 ),
)

  7. Compare o desempenho do modelo :

    • Use CompareModels() para avaliar diferentes modelos ou fornecedores.
    • Exemplo: 
       results , err := tools . CompareModels ( ctx , promptText , validateFunc , configs ... )

  8. Implementar memória para interações contextuais :

    • Habilite a retenção de memória para manter o contexto entre as interações.
    • Exemplo: 
       llm , err := gollm . NewLLM (
    gollm . SetProvider ( "openai" ),
    gollm . SetModel ( "gpt-3.5-turbo" ),
    gollm . SetMemory ( 4096 ),
)

  9. Manuseio de erros e tentativas :

    • Sempre verifique erros e configure mecanismos de tentativa.
    • Exemplo: 
       llm , err := gollm . NewLLM (
    gollm . SetMaxRetries ( 3 ),
    gollm . SetRetryDelay ( time . Second * 2 ),
)

  10. Manuseio de chave de API seguro :

    • Use variáveis ​​de ambiente para chaves da API.
    • Exemplo: 
       llm , err := gollm . NewLLM (
    gollm . SetAPIKey ( os . Getenv ( "OPENAI_API_KEY" )),
)

Exemplos e tutoriais

Confira nosso diretório de exemplos para obter mais exemplos de uso, incluindo:

  • Uso básico
  • Diferentes tipos de prompt
  • Comparando provedores
  • Modelos avançados de prompt
  • Otimização imediata
  • Validação de saída JSON
  • Mistura de agentes

Status do projeto

gollm é mantido ativamente e sob desenvolvimento contínuo. Com a recente refatoração, simplificamos a base de código para torná -la mais simples e mais acessível para novos colaboradores. Congratulamo -nos com contribuições e feedback da comunidade.

Filosofia

gollm é construído sobre uma filosofia de minimalismo pragmático e simplicidade de pensamento avançado:

  1. Construa o que é necessário : adicionamos recursos conforme necessário, evitando o desenvolvimento especulativo.

  2. Simplicidade primeiro : as adições devem ser diretas e cumprir seu objetivo.

  3. Futuro compatível : consideramos como as mudanças atuais podem afetar o desenvolvimento futuro.

  4. Contagem de legibilidade : O código deve ser claro e auto-explicativo.

  5. Design modular : cada componente deve fazer uma coisa bem.

Contribuindo

Congratulamo -nos com contribuições que se alinham à nossa filosofia! Esteja você consertando um bug, melhorando a documentação ou a proposição de novos recursos, seus esforços são apreciados.

Para começar:

  1. Familiarize -se com a nossa filosofia.
  2. Confira nosso contribuindo.md.
  3. Veja nossos problemas.
  4. Gire o repositório, faça suas alterações e envie uma solicitação de tração.

Obrigado por ajudar a melhorar gollm !

Licença

Este projeto está licenciado sob a licença Apache 2.0 - consulte o arquivo de licença para obter detalhes.

Expandir
Informações adicionais
Aplicativos Relacionados
Recomendado para você
Informações Relacionadas Todos