gollm - Go 大型语言模型

gollm是一个Go语言包，旨在帮助您构建自己的AI傀儡。就像传说中的魔像通过神圣词语被赋予生命一样，gollm使您能够利用大型语言模型（LLMs）的力量为AI创造物注入生命。这个包简化并优化了与各种LLM提供商的交互，为AI工程师和开发者提供了一个统一、灵活且强大的接口，以打造他们自己的数字仆从。

文档

主要特性

多LLM提供商统一API： 使用各种提供商（包括OpenAI、Anthropic Groq和Ollama）塑造您的傀儡的思维。无缝切换GPT-4、GPT-4o-mini、Claude和llama-3.1等模型。
轻松切换提供商和模型： 通过简单的函数调用配置首选提供商和模型，塑造您的傀儡的能力。
灵活的配置选项： 使用环境变量、基于代码的配置或配置文件自定义您的傀儡的本质，以适应您项目的需求。
高级提示工程： 精心设计复杂的指令，有效引导您的傀儡的响应。
PromptOptimizer： 自动改进和优化您的提示以获得更好的结果，支持自定义指标和不同的评分系统。
记忆保留： 在多次交互中保持上下文，实现更连贯的对话。
结构化输出和验证： 通过JSON模式生成和验证确保您的傀儡输出一致可靠。
提供商比较工具： 测试您的傀儡在不同LLM提供商和模型上执行相同任务的表现。
高级AI函数： 使用预构建的函数（如ChainOfThought）赋予您的傀儡复杂推理任务的能力。
强大的错误处理和重试机制： 通过内置的重试机制处理API速率限制和瞬时错误，为您的傀儡构建弹性。
可扩展架构： 通过扩展对新LLM提供商和功能的支持，轻松扩展您的傀儡的能力。

实际应用

您的gollm驱动的傀儡可以处理广泛的AI驱动任务，包括：

内容创作工作流： 为写作项目生成研究摘要、文章创意和精炼段落。
复杂推理任务： 使用ChainOfThought函数逐步分解和分析复杂问题。
结构化数据生成： 使用可自定义的JSON模式创建和验证复杂数据结构。
模型性能分析： 比较不同模型在特定任务上的表现，以优化您的AI流程。
提示优化： 自动改进各种任务的提示，从创意写作到技术文档。
混合代理： 结合多个LLM提供商的响应，创建多样化且强大的AI代理。

安装

go get github.com/teilomillet/gollm

快速入门

基本用法

package main

import (
	"context"
	"fmt"
	"log"

	"github.com/teilomillet/gollm"
)

func main() {
	llm, err := gollm.NewLLM(
		gollm.SetProvider("openai"),
		gollm.SetModel("gpt-4o-mini"),
		gollm.SetMaxTokens(100),
		gollm.SetAPIKey("your-api-key-here"),
	)
	if err != nil {
		log.Fatalf("创建LLM失败：%v", err)
	}

	ctx := context.Background()

	prompt := gollm.NewPrompt("讲一个关于编程的短笑话。")
	response, err := llm.Generate(ctx, prompt)
	if err != nil {
		log.Fatalf("生成文本失败：%v", err)
	}
	fmt.Printf("响应：%s\n", response)
}

有关更高级的用法，包括研究和内容优化，请查看examples目录。

快速参考

以下是gollm包中最常用函数和选项的快速参考指南：

LLM创建和配置

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("您的提示文本在这里",
    gollm.WithContext("附加上下文"),
    gollm.WithDirectives("保持简洁", "使用示例"),
    gollm.WithOutput("预期输出格式"),
    gollm.WithMaxLength(300),
)

生成响应

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

思维链

response, err := gollm.ChainOfThought(ctx, llm, "您的问题在这里")

提示优化

optimizer := gollm.NewPromptOptimizer(llm, initialPrompt, taskDescription,
    gollm.WithCustomMetrics(/* 自定义指标 */),
    gollm.WithRatingSystem("numerical"),
    gollm.WithThreshold(0.8),
)
optimizedPrompt, err := optimizer.OptimizePrompt(ctx)

模型比较

results, err := gollm.CompareModels(ctx, prompt, validateFunc, config1, config2, config3)

高级用法

gollm包提供了一系列高级功能来增强您的AI应用：

提示工程
预构建函数（如思维链）
使用示例
提示模板
结构化输出（JSON输出验证）
提示优化器
模型比较
记忆保留

以下是如何使用这些高级功能的示例：

提示工程

创建包含多个组件的复杂提示：

prompt := gollm.NewPrompt("解释编程中递归的概念。",
    gollm.WithContext("受众是初级程序员。"),
    gollm.WithDirectives(
        "使用简单的语言，避免行话。",
        "提供一个实际的例子。",
        "解释潜在的陷阱以及如何避免它们。",
    ),
    gollm.WithOutput("使用以下章节结构您的回答：定义、示例、陷阱、最佳实践。"),
    gollm.WithMaxLength(300),
)

response, err := llm.Generate(ctx, prompt)
if err != nil {
    log.Fatalf("生成解释失败：%v", err)
}

fmt.Printf("递归解释：\n%s\n", response)

预构建函数（思维链）

使用ChainOfThought函数进行步骤式推理：

question := "15 * 7 + 22的结果是多少？"
response, err := gollm.ChainOfThought(ctx, llm, question)
if err != nil {
    log.Fatalf("执行思维链失败：%v", err)
}
fmt.Printf("思维链：\n%s\n", response)

使用示例

直接从文件加载示例：

examples, err := gollm.readExamplesFromFile("examples.txt")
if err != nil {
    log.Fatalf("读取示例失败：%v", err)
}

prompt := gollm.NewPrompt("生成一个类似的示例：",
    gollm.WithExamples(examples...),
)

response, err := llm.Generate(ctx, prompt) 如果err不为nil { log.Fatalf("生成示例失败：%v", err) } fmt.Printf("生成的示例：\n%s\n", response)


### 提示模板

创建可重用的提示模板，以实现一致的提示生成：

```go
// 创建新的提示模板
template := gollm.NewPromptTemplate(
    "分析模板",
    "用于分析主题的模板",
    "请对{{.Topic}}进行全面分析。考虑以下几个方面：\n" +
    "1. 历史背景\n" +
    "2. 当前相关性\n" +
    "3. 未来影响",
    gollm.WithPromptOptions(
        gollm.WithDirectives(
            "使用清晰简洁的语言",
            "在适当的地方提供具体例子",
        ),
        gollm.WithOutput("为每个方面使用清晰的标题来组织你的分析。"),
    ),
)

// 使用模板创建提示
data := map[string]interface{}{
    "Topic": "医疗保健中的人工智能",
}
prompt, err := template.Execute(data)
如果err不为nil {
    log.Fatalf("执行模板失败：%v", err)
}

// 使用创建的提示生成回应
response, err := llm.Generate(ctx, prompt)
如果err不为nil {
    log.Fatalf("生成回应失败：%v", err)
}

fmt.Printf("分析：\n%s\n", response)

结构化输出（JSON输出验证）

确保你的LLM输出是有效的JSON格式：

prompt := gollm.NewPrompt("分析远程工作的利弊。",
    gollm.WithOutput("以JSON格式回应，包含'topic'、'pros'、'cons'和'conclusion'字段。"),
)

response, err := llm.Generate(ctx, prompt, gollm.WithJSONSchemaValidation())
如果err不为nil {
    log.Fatalf("生成有效分析失败：%v", err)
}

var result AnalysisResult
如果err := json.Unmarshal([]byte(response), &result); err != nil {
    log.Fatalf("解析回应失败：%v", err)
}

fmt.Printf("分析：%+v\n", result)

提示优化器

使用PromptOptimizer自动优化和改进你的提示：

initialPrompt := "写一个关于机器人学会爱的短篇故事。"
taskDescription := "生成一个引人入胜的短篇故事，探讨人工智能发展情感的主题。"

optimizer := gollm.NewPromptOptimizer(llm, initialPrompt, taskDescription,
    gollm.WithCustomMetrics(
        gollm.Metric{Name: "创造性", Description: "故事的原创性和想象力"},
        gollm.Metric{Name: "情感影响", Description: "故事唤起读者情感的程度"},
    ),
    gollm.WithRatingSystem("numerical"),
    gollm.WithThreshold(0.8),
    gollm.WithVerbose(),
)

optimizedPrompt, err := optimizer.OptimizePrompt(ctx)
如果err不为nil {
    log.Fatalf("优化失败：%v", err)
}

fmt.Printf("优化后的提示：%s\n", optimizedPrompt)

模型比较

比较不同LLM提供商或模型的回应：

configs := []*gollm.Config{
    {Provider: "openai", Model: "gpt-4o-mini", APIKey: "你的openai-api-key"},
    {Provider: "anthropic", Model: "claude-3-5-sonnet-20240620", APIKey: "你的anthropic-api-key"},
    {Provider: "groq", Model: "llama-3.1-70b-versatile", APIKey: "你的groq-api-key"},
}

prompt := "讲一个关于编程的笑话。以JSON格式回应，包含'setup'和'punchline'字段。"

results, err := gollm.CompareModels(context.Background(), prompt, validateJoke, configs...)
如果err不为nil {
    log.Fatalf("比较模型时出错：%v", err)
}

fmt.Println(gollm.AnalyzeComparisonResults(results))

记忆保留

启用记忆功能以在多次交互中保持上下文：

llm, err := gollm.NewLLM(
    gollm.SetProvider("openai"),
    gollm.SetModel("gpt-3.5-turbo"),
    gollm.SetAPIKey(os.Getenv("OPENAI_API_KEY")),
    gollm.SetMemory(4096), // 启用记忆功能，token限制为4096
)
如果err不为nil {
    log.Fatalf("创建LLM失败：%v", err)
}

ctx := context.Background()

// 第一次交互
prompt1 := gollm.NewPrompt("法国的首都是什么？")
response1, err := llm.Generate(ctx, prompt1)
如果err不为nil {
    log.Fatalf("生成回应失败：%v", err)
}
fmt.Printf("回应1：%s\n", response1)

// 第二次交互，引用第一次的内容
prompt2 := gollm.NewPrompt("那个城市的人口是多少？")
response2, err := llm.Generate(ctx, prompt2)
如果err不为nil {
    log.Fatalf("生成回应失败：%v", err)
}
fmt.Printf("回应2：%s\n", response2)

最佳实践

提示工程：

使用NewPrompt()函数，配合WithContext()、WithDirectives()和WithOutput()等选项来创建结构良好的提示。

示例：

prompt := gollm.NewPrompt("你的主要提示在此",
    gollm.WithContext("提供相关上下文"),
    gollm.WithDirectives("简洁", "使用示例"),
    gollm.WithOutput("指定预期的输出格式"),
)

使用提示模板：

为了一致的提示生成，创建并使用PromptTemplate对象。

示例：

template := gollm.NewPromptTemplate(
    "自定义模板",
    "用于自定义提示的模板",
    "生成一个关于{{.Topic}}的{{.Type}}",
    gollm.WithPromptOptions(
        gollm.WithDirectives("富有创意", "使用生动的语言"),
        gollm.WithOutput("你的{{.Type}}："),
    ),
)

利用预构建函数：
- 使用提供的函数如ChainOfThought()来处理复杂的推理任务。
- 示例：
```
response, err := gollm.ChainOfThought(ctx, llm, "你的复杂问题在此")
```

使用示例：

使用readExamplesFromFile()函数从文件加载示例，以获得更一致和多样的输出。

示例：

examples, err := gollm.readExamplesFromFile("examples.txt")
如果err不为nil {
    log.Fatalf("读取示例失败：%v", err)
}

实现结构化输出：
- 生成回应时使用WithJSONSchemaValidation()选项以确保有效的JSON输出。
- 示例：
```
response, err := llm.Generate(ctx, prompt, gollm.WithJSONSchemaValidation())
```

优化提示：

利用PromptOptimizer自动优化和改进你的提示。

示例：

optimizer := gollm.NewPromptOptimizer(llm, initialPrompt, taskDescription,
    gollm.WithCustomMetrics(
        gollm.Metric{Name: "相关性", Description: "回应与任务的相关程度"},
    ),
    gollm.WithRatingSystem("numerical"),
    gollm.WithThreshold(0.8),
)
optimizedPrompt, err := optimizer.OptimizePrompt(ctx)

比较模型性能：
- 使用CompareModels()函数评估不同模型或提供商在特定任务上的表现。
- 示例：
```
results, err := gollm.CompareModels(ctx, prompt, validateFunc, config1, config2, config3)
```

实现上下文记忆：

启用记忆保留功能以在多次交互中维持上下文。

示例：

llm, err := gollm.NewLLM(
    gollm.SetProvider("openai"),
    gollm.SetModel("gpt-3.5-turbo"),
    gollm.SetMemory(4096), // 启用记忆功能，token限制为4096
)

错误处理和重试：
- 始终检查gollm函数返回的错误。
- 配置重试机制以处理暂时性错误和速率限制。
- 示例：
```
llm, err := gollm.NewLLM(
    gollm.SetMaxRetries(3),
    gollm.SetRetryDelay(time.Second * 2),
)
```
安全处理API密钥：
- 使用环境变量或安全配置管理来处理API密钥。
- 示例：
```
llm, err := gollm.NewLLM(
    gollm.SetAPIKey(os.Getenv("OPENAI_API_KEY")),
)
```