首页
/ LangChain Go流式响应实现：提升用户体验

LangChain Go流式响应实现：提升用户体验

2026-02-05 05:22:09作者：何举烈Damon
langchaingo
LangChain for Go, the easiest way to write LLM-based programs in Go
项目地址：https://gitcode.com/GitHub_Trending/la/langchaingo

在构建基于大语言模型（LLM）的应用时，用户体验往往取决于响应速度和交互流畅度。传统的完整结果返回方式需要用户等待整个生成过程完成，这在处理长文本或复杂任务时会导致明显的延迟感。LangChain Go（doc.go）提供的流式响应（Streaming Response）功能通过逐段返回生成结果，显著改善了这一体验，让AI交互更加自然流畅。

流式响应的工作原理

流式响应允许LLM在生成内容的同时立即将结果片段发送给用户，而不是等待整个响应完成。这种方式模拟了人类的思考和表达过程，使用户能够更早地看到内容并与之交互。

在LangChain Go中，流式响应通过Go语言的channel机制实现。当调用流式生成方法时，会返回一个只读channel，应用程序可以通过这个channel接收连续的结果片段。

// 流式响应的核心接口定义
stream, err := llm.GenerateContentStream(ctx, messages)
if err != nil {
    log.Fatal(err)
}
defer stream.Close()

// 通过channel接收流式结果
for stream.Next() {
    chunk := stream.Value()
    fmt.Print(chunk.Choices[0].Content) // 实时处理每个片段
}

if err := stream.Err(); err != nil {
    log.Fatal(err)
}

基础实现：从同步到流式

要在LangChain Go中实现流式响应，首先需要了解基础的同步调用与流式调用的区别。

同步调用方式

传统的同步调用会阻塞直到完整结果返回：

// 同步调用示例
completion, err := llm.GenerateContent(ctx, []llms.MessageContent{
    llms.TextParts(llms.ChatMessageTypeHuman, "请详细介绍Go语言的优势"),
})
if err != nil {
    log.Fatal(err)
}
fmt.Println(completion.Choices[0].Content)

流式调用方式

流式调用则立即返回一个channel，通过该channel异步接收结果片段：

// 流式调用示例
stream, err := llm.GenerateContentStream(ctx, []llms.MessageContent{
    llms.TextParts(llms.ChatMessageTypeHuman, "请详细介绍Go语言的优势"),
})
if err != nil {
    log.Fatal(err)
}
defer stream.Close()

for stream.Next() {
    chunk := stream.Value()
    fmt.Print(chunk.Choices[0].Content) // 实时输出每个片段
}

if err := stream.Err(); err != nil {
    log.Printf("流式响应错误: %v", err)
}

主流LLM提供商的流式实现

LangChain Go为不同的LLM提供商实现了流式响应接口，以下是几个主流提供商的实现方式。

OpenAI流式实现

OpenAI的API通过SSE（Server-Sent Events）协议提供流式响应，LangChain Go将其封装为channel接口：

import (
    "context"
    "fmt"
    "log"
    
    "github.com/tmc/langchaingo/llms"
    "github.com/tmc/langchaingo/llms/openai"
)

func main() {
    ctx := context.Background()
    
    // 创建OpenAI实例
    llm, err := openai.New(openai.WithModel("gpt-4-streaming"))
    if err != nil {
        log.Fatal(err)
    }
    
    // 发起流式请求
    stream, err := llm.GenerateContentStream(ctx, []llms.MessageContent{
        llms.TextParts(llms.ChatMessageTypeHuman, "请用流式方式介绍Go语言的主要特性"),
    })
    if err != nil {
        log.Fatal(err)
    }
    defer stream.Close()
    
    // 处理流式响应
    fmt.Println("开始接收流式响应:")
    for stream.Next() {
        chunk := stream.Value()
        fmt.Print(chunk.Choices[0].Content)
    }
    
    if err := stream.Err(); err != nil {
        log.Printf("流式响应完成时出错: %v", err)
    }
}

Ollama本地模型流式实现

对于本地部署的Ollama模型，流式响应可以避免长时间阻塞：

import (
    "context"
    "fmt"
    "log"
    
    "github.com/tmc/langchaingo/llms"
    "github.com/tmc/langchaingo/llms/ollama"
)

func main() {
    ctx := context.Background()
    
    // 创建Ollama实例，连接本地模型
    llm, err := ollama.New(
        ollama.WithModel("llama3"),
        ollama.WithServerURL("http://localhost:11434"),
    )
    if err != nil {
        log.Fatal(err)
    }
    
    // 发起流式请求
    stream, err := llm.GenerateContentStream(ctx, []llms.MessageContent{
        llms.TextParts(llms.ChatMessageTypeHuman, "请解释什么是微服务架构"),
    })
    if err != nil {
        log.Fatal(err)
    }
    defer stream.Close()
    
    // 处理流式响应
    for stream.Next() {
        chunk := stream.Value()
        fmt.Print(chunk.Choices[0].Content)
    }
    
    if err := stream.Err(); err != nil {
        log.Printf("流式响应错误: %v", err)
    }
}

高级应用：构建实时聊天界面

流式响应最常见的应用场景是构建实时聊天界面。以下是一个使用Gin框架构建的简单Web聊天应用，展示如何将LangChain Go的流式响应集成到Web环境中。

后端实现

// main.go
package main

import (
    "context"
    "fmt"
    "log"
    "net/http"
    "github.com/gin-gonic/gin"
    "github.com/tmc/langchaingo/llms"
    "github.com/tmc/langchaingo/llms/ollama"
)

func main() {
    r := gin.Default()
    
    // 聊天接口，使用流式响应
    r.POST("/chat", func(c *gin.Context) {
        var request struct {
            Message string `json:"message"`
        }
        
        if err := c.ShouldBindJSON(&request); err != nil {
            c.JSON(http.StatusBadRequest, gin.H{"error": err.Error()})
            return
        }
        
        // 设置响应头，启用SSE
        c.Header("Content-Type", "text/event-stream")
        c.Header("Cache-Control", "no-cache")
        c.Header("Connection", "keep-alive")
        
        // 创建LLM实例
        llm, err := ollama.New(
            ollama.WithModel("llama3"),
            ollama.WithServerURL("http://localhost:11434"),
        )
        if err != nil {
            c.JSON(http.StatusInternalServerError, gin.H{"error": err.Error()})
            return
        }
        
        // 发起流式请求
        stream, err := llm.GenerateContentStream(c.Request.Context(), []llms.MessageContent{
            llms.TextParts(llms.ChatMessageTypeHuman, request.Message),
        })
        if err != nil {
            c.JSON(http.StatusInternalServerError, gin.H{"error": err.Error()})
            return
        }
        defer stream.Close()
        
        // 将流式结果通过SSE发送给前端
        for stream.Next() {
            chunk := stream.Value()
            if chunk.Choices != nil && len(chunk.Choices) > 0 {
                // 使用SSE格式发送数据
                fmt.Fprintf(c.Writer, "data: %s\n\n", chunk.Choices[0].Content)
                c.Writer.Flush() // 立即发送数据
            }
        }
        
        if err := stream.Err(); err != nil {
            log.Printf("流式响应错误: %v", err)
            fmt.Fprintf(c.Writer, "data: [ERROR] %s\n\n", err.Error())
            c.Writer.Flush()
        }
        
        // 发送完成信号
        fmt.Fprintf(c.Writer, "data: [DONE]\n\n")
        c.Writer.Flush()
    })
    
    log.Fatal(r.Run(":8080"))
}

前端实现

<!DOCTYPE html>
<html>
<head>
    <title>LangChain Go 流式聊天示例</title>
    <style>
        #chat-container { width: 600px; margin: 20px auto; }
        #messages { border: 1px solid #ccc; height: 400px; padding: 10px; overflow-y: auto; margin-bottom: 10px; }
        #input-container { display: flex; }
        #message-input { flex: 1; padding: 8px; }
        #send-button { padding: 8px 16px; margin-left: 8px; }
        .message { margin: 5px 0; padding: 8px; border-radius: 4px; }
        .user-message { background-color: #e3f2fd; text-align: right; }
        .ai-message { background-color: #f5f5f5; }
    </style>
</head>
<body>
    <div id="chat-container">
        <div id="messages"></div>
        <div id="input-container">
            <input type="text" id="message-input" placeholder="输入消息...">
            <button id="send-button">发送</button>
        </div>
    </div>

    <script>
        const messagesDiv = document.getElementById('messages');
        const input = document.getElementById('message-input');
        const button = document.getElementById('send-button');

        button.addEventListener('click', sendMessage);
        input.addEventListener('keypress', (e) => {
            if (e.key === 'Enter') sendMessage();
        });

        function addMessage(text, isUser) {
            const messageDiv = document.createElement('div');
            messageDiv.className = isUser ? 'message user-message' : 'message ai-message';
            messageDiv.textContent = text;
            messagesDiv.appendChild(messageDiv);
            messagesDiv.scrollTop = messagesDiv.scrollHeight;
        }

        function sendMessage() {
            const text = input.value.trim();
            if (!text) return;
            
            addMessage(text, true);
            input.value = '';
            
            const aiMessageDiv = document.createElement('div');
            aiMessageDiv.className = 'message ai-message';
            messagesDiv.appendChild(aiMessageDiv);
            messagesDiv.scrollTop = messagesDiv.scrollHeight;
            
            // 发起流式请求
            const eventSource = new EventSource(`/chat?message=${encodeURIComponent(text)}`);
            
            eventSource.onmessage = (event) => {
                if (event.data === '[DONE]') {
                    eventSource.close();
                    return;
                }
                if (event.data.startsWith('[ERROR]')) {
                    aiMessageDiv.textContent = event.data.substring(7);
                    eventSource.close();
                    return;
                }
                aiMessageDiv.textContent += event.data;
                messagesDiv.scrollTop = messagesDiv.scrollHeight;
            };
            
            eventSource.onerror = (error) => {
                console.error('EventSource error:', error);
                eventSource.close();
            };
        }
    </script>
</body>
</html>

错误处理与最佳实践

流式响应的错误处理需要特别注意，因为错误可能在流传输过程中的任何时候发生。

完善的错误处理

stream, err := llm.GenerateContentStream(ctx, messages)
if err != nil {
    // 初始错误处理
    log.Printf("创建流失败: %v", err)
    return err
}
defer func() {
    // 确保流被关闭
    if err := stream.Close(); err != nil {
        log.Printf("关闭流时出错: %v", err)
    }
}()

for stream.Next() {
    chunk := stream.Value()
    // 处理每个片段
    processChunk(chunk)
}

// 检查流结束时的错误
if err := stream.Err(); err != nil {
    log.Printf("流处理错误: %v", err)
    
    // 根据错误类型进行不同处理
    if llms.IsAuthenticationError(err) {
        log.Println("认证错误，请检查API密钥")
    } else if llms.IsRateLimitError(err) {
        log.Println("已达到API速率限制，请稍后再试")
    } else if llms.IsModelError(err) {
        log.Println("模型错误，请检查模型名称和配置")
    }
    
    return err
}

性能优化建议

  1. 缓冲区管理：对于高频更新的UI，考虑使用缓冲区合并小的输出片段，减少渲染次数

  2. 上下文控制：使用context.WithTimeout设置合理的超时时间，避免流无限期阻塞

  3. 背压处理：如果处理速度跟不上流产生的速度，实现适当的背压机制

// 带超时和取消功能的流式调用
ctx, cancel := context.WithTimeout(context.Background(), 5*time.Minute)
defer cancel()

stream, err := llm.GenerateContentStream(ctx, messages)
// ...

流式响应的应用场景

流式响应在多种场景中能显著提升用户体验：

  1. 实时聊天应用：如前面示例所示，提供类人类的打字体验

  2. 长文本生成：论文、报告等长文本的实时生成与预览

  3. 代码生成：实时生成代码并展示语法高亮

  4. 实时数据处理：结合工具调用，流式展示数据处理进度

  5. 教育类应用：逐步展示解题过程或知识点讲解

总结与未来展望

LangChain Go的流式响应功能通过Go语言强大的并发特性，为LLM应用提供了高效、灵活的实时交互能力。从简单的命令行工具到复杂的Web应用，流式响应都能显著改善用户体验，减少等待感。

随着LLM技术的发展，流式响应将支持更丰富的交互模式，如：

  • 中间结果的实时编辑和修正
  • 多模态内容的流式生成（文本、图像、音频的混合流）
  • 基于用户反馈的动态生成调整

要深入了解LangChain Go的流式响应实现，可以参考以下资源：

通过合理利用流式响应，开发者可以构建出更自然、更流畅的AI应用，为用户带来卓越的交互体验。

langchaingo
LangChain for Go, the easiest way to write LLM-based programs in Go
项目地址：https://gitcode.com/GitHub_Trending/la/langchaingo
登录后查看全文
热门项目推荐
相关项目推荐

项目优选

收起
kernelkernel
deepin linux kernel
C
32
16
kernelkernel
openEuler内核是openEuler操作系统的核心，既是系统性能与稳定性的基石，也是连接处理器、设备与服务的桥梁。
C
468
461
docsdocs
暂无描述
Dockerfile
776
5.07 K
pytorchpytorch
Ascend Extension for PyTorch
Python
756
961
ops-transformerops-transformer
本项目是CANN提供的transformer类大模型算子库，实现网络在NPU上加速计算。
C++
872
2.01 K
ops-nnops-nn
本项目是CANN提供的神经网络类计算算子库，实现网络在NPU上加速计算。
C++
696
1.4 K
MindSpeed-LLMMindSpeed-LLM
昇腾LLM分布式训练框架
Python
183
230
ops-mathops-math
本项目是CANN提供的数学类基础计算算子库，实现网络在NPU上加速计算。
C++
1.1 K
1.14 K
flutter_flutterflutter_flutter
本仓库是 Flutter SDK 与 Flutter Engine 的 OpenHarmony 适配版本，由 CPF-Flutter 团队维护。开发者可使用熟悉的 Flutter 技术栈开发 OpenHarmony 应用，3.35.7 及以后的适配版本可基于本仓库源码构建支持 OpenHarmony 的 Flutter Engine。
Dart
1.04 K
271
Oohos_react_native
React Native鸿蒙化仓库
C++
361
430