看看网 - Go语言与AI技术文档

安装 Go

Go 支持多种操作系统，包括 Windows、macOS 和 Linux。你可以从官网下载安装包，或使用包管理器进行安装。

bash

# macOS 使用 Homebrew
$ brew install go

# Ubuntu/Debian
$ sudo apt-get install golang-go

# 验证安装
$ go version
go version go1.24.0 darwin/arm64

Hello World

让我们从经典的 "Hello, World!" 程序开始。创建一个名为 main.go 的文件：

go

package main

import "fmt"

func main() {
    fmt.Println("Hello, World!")
}

运行程序：

bash

$ go run main.go
Hello, World!

工作空间

Go 使用工作空间（workspace）来组织代码。从 Go 1.18 开始，可以使用 go.work 文件管理多模块工作空间。

bash

# 初始化工作空间
$ go work init ./module1 ./module2

# 查看工作空间结构
$ cat go.work
go 1.24

use (
    ./module1
    ./module2
)

模块管理

Go Modules 是 Go 的官方依赖管理工具，从 Go 1.11 开始引入，Go 1.16 后成为默认方式。

bash

# 初始化模块
$ go mod init github.com/username/project

# 下载依赖
$ go mod tidy

# 查看依赖
$ go list -m all

# 更新依赖
$ go get -u ./...

变量与常量

Go 使用 var 关键字声明变量，使用 const 关键字声明常量。支持类型推断和短变量声明。

go

package main

import "fmt"

func main() {
    // 完整声明
    var name string = "Go"
    
    // 类型推断
    var age = 15
    
    // 短变量声明（函数内使用）
    version := 1.24
    
    // 常量
    const Pi = 3.14159
    
    // 多变量声明
    var a, b, c int = 1, 2, 3
    
    fmt.Println(name, age, version, Pi, a, b, c)
}

函数

函数是 Go 的核心构建块。支持多返回值、变长参数、匿名函数和闭包。

go

package main

import "fmt"

// 基本函数
func add(a, b int) int {
    return a + b
}

// 多返回值
func divide(a, b float64) (float64, error) {
    if b == 0 {
        return 0, fmt.Errorf("cannot divide by zero")
    }
    return a / b, nil
}

// 变长参数
func sum(nums ...int) int {
    total := 0
    for _, n := range nums {
        total += n
    }
    return total
}

func main() {
    fmt.Println(add(3, 5))
    
    result, err := divide(10, 2)
    if err != nil {
        fmt.Println("Error:", err)
    } else {
        fmt.Println("Result:", result)
    }
    
    fmt.Println(sum(1, 2, 3, 4, 5))
}

结构体

结构体（struct）是 Go 中自定义类型的主要方式，用于组合相关字段。支持嵌入类型和方法。

go

package main

import "fmt"

// 定义结构体
type Person struct {
    Name   string
    Age    int
    Email  string
}

// 方法
func (p Person) Info() string {
    return fmt.Sprintf("%s is %d years old", p.Name, p.Age)
}

// 指针接收者方法（可修改原值）
func (p *Person) Birthday() {
    p.Age++
}

func main() {
    // 创建实例
    p1 := Person{Name: "Alice", Age: 30, Email: "alice@example.com"}
    
    // 使用 new
    p2 := new(Person)
    p2.Name = "Bob"
    p2.Age = 25
    
    fmt.Println(p1.Info())
    p1.Birthday()
    fmt.Println(p1.Info())
}

接口

接口定义了一组方法签名。Go 的接口是隐式实现的，无需显式声明实现了哪个接口。

go

package main

import "fmt"

// 定义接口
type Shape interface {
    Area() float64
    Perimeter() float64
}

// 矩形
type Rectangle struct {
    Width, Height float64
}

func (r Rectangle) Area() float64 {
    return r.Width * r.Height
}

func (r Rectangle) Perimeter() float64 {
    return 2 * (r.Width + r.Height)
}

// 圆形
type Circle struct {
    Radius float64
}

func (c Circle) Area() float64 {
    return 3.14159 * c.Radius * c.Radius
}

func (c Circle) Perimeter() float64 {
    return 2 * 3.14159 * c.Radius
}

func PrintShapeInfo(s Shape) {
    fmt.Printf("Area: %.2f, Perimeter: %.2f\n", s.Area(), s.Perimeter())
}

func main() {
    r := Rectangle{Width: 10, Height: 5}
    c := Circle{Radius: 7}
    
    PrintShapeInfo(r)
    PrintShapeInfo(c)
}

并发编程

Go 语言的并发模型基于 CSP（通信顺序进程），通过 goroutine 和 channel 实现：

go

package main

import (
    "fmt"
    "time"
)

func worker(id int, jobs <-chan int, results chan<- int) {
    for j := range jobs {
        fmt.Printf("worker %d processing job %d\n", id, j)
        time.Sleep(time.Second)
        results <- j * 2
    }
}

func main() {
    jobs := make(chan int, 100)
    results := make(chan int, 100)

    for w := 1; w <= 3; w++ {
        go worker(w, jobs, results)
    }

    for j := 1; j <= 5; j++ {
        jobs <- j
    }
    close(jobs)

    for a := 1; a <= 5; a++ {
        <-results
    }
}

Go 语言 AI 开发概览 AI

Go 语言凭借其出色的并发性能和简洁的语法，成为构建 AI 应用后端的理想选择。2026年，Go 在 AI 领域的生态系统日趋成熟，支持各种主流大语言模型和 AI 服务。

为什么选择 Go 开发 AI 应用？

Go 的高并发特性使其能够高效处理大量 AI 推理请求，内存占用低、启动速度快，非常适合构建 AI 微服务和 Serverless 应用。

主流 AI 服务 Go SDK

🌙

Anthropic Go

官方 Go SDK，支持 Claude 4.6 系列模型

🔷

Google GenAI

Gemini 2.0 系列模型 Go 客户端

🦙

Ollama Go

本地大模型部署与调用

📊

Pinecone

向量数据库 Go 客户端

LLM API 调用 AI

使用 Go 调用 Anthropic API 进行聊天补全，支持最新的 Claude 4.6 模型：

go

package main

import (
    "context"
    "fmt"
    "os"

    "github.com/anthropics/anthropic-go"
)

func main() {
    client := anthropic.NewClient(
        os.Getenv("ANTHROPIC_API_KEY"),
    )

    resp, err := client.Messages.Create(
        context.TODO(),
        anthropic.MessageNewParams{
            Model:     "claude-4-6-sonnet-20260325",
            MaxTokens: 2000,
            Messages: []anthropic.MessageParam{
                {
                    Role:    "user",
                    Content: "用 Go 写一个快速排序",
                },
            },
            Temperature: 0.7,
        },
    )
    if err != nil {
        panic(err)
    }

    fmt.Println(resp.Content[0].Text)
}

Claude 4.6 Opus 调用示例

go

package main

import (
    "context"
    "fmt"
    "log"
    "os"

    "github.com/anthropics/anthropic-go"
)

func main() {
    client := anthropic.NewClient(
        os.Getenv("ANTHROPIC_API_KEY"),
    )

    resp, err := client.Messages.Create(
        context.Background(),
        anthropic.MessageNewParams{
            Model:     "claude-4-6-opus-20260325",
            MaxTokens: 4096,
            Messages: []anthropic.MessageParam{
                {
                    Role:    "user",
                    Content: "解释 Go 的 channel 机制",
                },
            },
            Temperature: 0.7,
        },
    )
    if err != nil {
        log.Fatal(err)
    }

    fmt.Println(resp.Content[0].Text)
}

流式响应处理 AI

实现 SSE (Server-Sent Events) 流式输出，提供流畅的 AI 对话体验：

go

package main

import (
    "context"
    "encoding/json"
    "fmt"
    "net/http"

    "github.com/anthropics/anthropic-go"
)

type StreamHandler struct {
    client *anthropic.Client
}

func (h *StreamHandler) HandleChat(w http.ResponseWriter, r *http.Request) {
    w.Header().Set("Content-Type", "text/event-stream")
    w.Header().Set("Cache-Control", "no-cache")
    w.Header().Set("Connection", "keep-alive")

    stream, err := h.client.Messages.CreateStreaming(
        r.Context(),
        anthropic.MessageNewParams{
            Model:     "claude-4-6-sonnet-20260325",
            MaxTokens: 2000,
            Messages: []anthropic.MessageParam{
                {
                    Role:    "user",
                    Content: r.URL.Query().Get("q"),
                },
            },
        },
    )
    if err != nil {
        http.Error(w, err.Error(), 500)
        return
    }

    flusher, _ := w.(http.Flusher)
    for stream.Next() {
        event := stream.Current()
        if event.Type == "content_block_delta" {
            data, _ := json.Marshal(map[string]string{
                "content": event.Delta.Text,
            })
            fmt.Fprintf(w, "data: %s\n\n", data)
            flusher.Flush()
        }
    }
}

文本嵌入向量 AI

使用 Embedding API 将文本转换为向量，用于语义搜索和相似度计算：

go

package embedding

import (
    "context"
    "math"

    "github.com/anthropics/anthropic-go"
)

type EmbeddingService struct {
    client *anthropic.Client
}

func (s *EmbeddingService) CreateEmbedding(
    ctx context.Context, 
    text string,
) ([]float32, error) {
    resp, err := s.client.Embeddings.Create(ctx, 
        anthropic.EmbeddingNewParams{
            Model: "claude-embedding-3",
            Input: text,
        })
    if err != nil {
        return nil, err
    }
    return resp.Embedding, nil
}

// CosineSimilarity 计算两个向量的余弦相似度
func CosineSimilarity(a, b []float32) float64 {
    var dotProduct, normA, normB float64
    for i := 0; i < len(a); i++ {
        dotProduct += float64(a[i] * b[i])
        normA += float64(a[i] * a[i])
        normB += float64(b[i] * b[i])
    }
    return dotProduct / (math.Sqrt(normA) * math.Sqrt(normB))
}

RAG 检索增强生成 AI

构建 RAG 系统，结合向量数据库实现知识库问答：

go

package rag

import (
    "context"
    "fmt"
    "strings"

    "github.com/anthropics/anthropic-go"
    "github.com/pgvector/pgvector-go"
    "github.com/jackc/pgx/v5"
)

type RAGService struct {
    llm        *anthropic.Client
    db         *pgx.Conn
    embedder   *EmbeddingService
}

// AddDocument 添加文档到知识库
func (r *RAGService) AddDocument(
    ctx context.Context, 
    content string,
) error {
    embedding, err := r.embedder.CreateEmbedding(ctx, content)
    if err != nil {
        return err
    }

    _, err = r.db.Exec(ctx,
        `INSERT INTO documents (content, embedding) 
         VALUES ($1, $2)`,
        content, pgvector.NewVector(embedding))
    return err
}

// Query 执行 RAG 查询
func (r *RAGService) Query(
    ctx context.Context, 
    question string,
) (string, error) {
    // 1. 获取问题的向量表示
    queryEmbedding, err := r.embedder.CreateEmbedding(ctx, question)
    if err != nil {
        return "", err
    }

    // 2. 检索相似文档
    rows, err := r.db.Query(ctx,
        `SELECT content FROM documents 
         ORDER BY embedding <=> $1 LIMIT 5`,
        pgvector.NewVector(queryEmbedding))
    if err != nil {
        return "", err
    }
    defer rows.Close()

    var contexts []string
    for rows.Next() {
        var content string
        rows.Scan(&content)
        contexts = append(contexts, content)
    }

    // 3. 构建增强提示
    prompt := fmt.Sprintf(`基于以下上下文回答问题：

%s

问题：%s`, 
        strings.Join(contexts, "\n\n"), question)

    // 4. 调用 Claude 生成回答
    resp, err := r.llm.Messages.Create(ctx,
        anthropic.MessageNewParams{
            Model:     "claude-4-6-sonnet-20260325",
            MaxTokens: 2000,
            Messages: []anthropic.MessageParam{
                {
                    Role:    "user",
                    Content: "你是一个知识库助手。\n\n" + prompt,
                },
            },
        })
    if err != nil {
        return "", err
    }

    return resp.Content[0].Text, nil
}

AI Agent 开发 AI

构建具备工具调用能力的 AI Agent，实现自动化任务处理：

go

package agent

import (
    "context"
    "encoding/json"
    "fmt"

    "github.com/anthropics/anthropic-go"
)

type Tool struct {
    Name        string
    Description string
    Parameters  map[string]interface{}
    Handler     func(map[string]interface{}) (string, error)
}

type Agent struct {
    client *anthropic.Client
    tools  map[string]*Tool
}

func (a *Agent) RegisterTool(tool *Tool) {
    a.tools[tool.Name] = tool
}

func (a *Agent) Run(ctx context.Context, input string) (string, error) {
    messages := []anthropic.MessageParam{
        {
            Role:    "user",
            Content: "你是一个 helpful 助手，可以调用工具完成任务。\n\n" + input,
        },
    }

    // 构建工具定义
    var toolDefs []anthropic.ToolParam
    for _, tool := range a.tools {
        toolDefs = append(toolDefs, anthropic.ToolParam{
            Name:        tool.Name,
            Description: tool.Description,
            InputSchema: tool.Parameters,
        })
    }

    // 第一次调用，可能触发工具调用
    resp, err := a.client.Messages.Create(ctx,
        anthropic.MessageNewParams{
            Model:     "claude-4-6-sonnet-20260325",
            MaxTokens: 2000,
            Messages:  messages,
            Tools:     toolDefs,
        })
    if err != nil {
        return "", err
    }

    // 处理工具调用
    if len(resp.Content) > 0 && resp.Content[0].Type == "tool_use" {
        toolUse := resp.Content[0].ToolUse
        tool := a.tools[toolUse.Name]
        
        var args map[string]interface{}
        json.Unmarshal([]byte(toolUse.Input), &args)

        result, err := tool.Handler(args)
        if err != nil {
            result = fmt.Sprintf("Error: %v", err)
        }

        // 添加工具调用结果到上下文
        messages = append(messages, anthropic.MessageParam{
            Role: "assistant",
            Content: fmt.Sprintf("Tool: %s, Result: %s", 
                toolUse.Name, result),
        })

        // 第二次调用获取最终回答
        finalResp, _ := a.client.Messages.Create(ctx,
            anthropic.MessageNewParams{
                Model:     "claude-4-6-sonnet-20260325",
                MaxTokens: 2000,
                Messages:  messages,
            })
        return finalResp.Content[0].Text, nil
    }

    return resp.Content[0].Text, nil
}

向量数据库 AI

使用 Pinecone 进行高性能向量检索：

go

package vectordb

import (
    "context"

    "github.com/pinecone-io/go-pinecone/pinecone"
)

type PineconeStore struct {
    client    *pinecone.Client
    index     pinecone.IndexInterface
    indexName string
}

func NewPineconeStore(apiKey, indexName string) (*PineconeStore, error) {
    client, err := pinecone.NewClient(
        pinecone.NewClientParams{ApiKey: apiKey})
    if err != nil {
        return nil, err
    }

    index, err := client.Index(
        context.Background(),
        pinecone.NewIndexParams{Host: "your-index-host"})
    if err != nil {
        return nil, err
    }

    return &PineconeStore{
        client:    client,
        index:     index,
        indexName: indexName,
    }, nil
}

func (s *PineconeStore) UpsertVectors(
    ctx context.Context,
    vectors []pinecone.Vector,
) error {
    _, err := s.index.UpsertVectors(ctx, &pinecone.UpsertVectorsRequest{
        Vectors: vectors,
    })
    return err
}

func (s *PineconeStore) Query(
    ctx context.Context,
    vector []float32,
    topK uint32,
) ([]pinecone.ScoredVector, error) {
    resp, err := s.index.Query(ctx, &pinecone.QueryRequest{
        Vector:       vector,
        TopK:         topK,
        IncludeValues: false,
    })
    if err != nil {
        return nil, err
    }
    return resp.Matches, nil
}

MCP 协议集成 AI NEW

Model Context Protocol (MCP) 是 2026 年推出的开放协议，用于标准化 AI 模型与外部工具的交互：

什么是 MCP？

MCP (Model Context Protocol) 是由 Anthropic 提出的开放标准，旨在统一 AI 模型与数据源、工具之间的通信方式，类似于 AI 世界的 "USB-C" 接口。

go

package mcp

import (
    "os"

    "github.com/modelcontextprotocol/go-sdk/mcp"
)

type MCPServer struct {
    server *mcp.Server
    tools  map[string]MCPTool
}

type MCPTool struct {
    Name        string                 `json:"name"`
    Description string                 `json:"description"`
    InputSchema map[string]interface{} `json:"inputSchema"`
    Handler     func(map[string]interface{}) (*mcp.CallToolResult, error)
}

func NewMCPServer(name, version string) *MCPServer {
    s := &MCPServer{
        server: mcp.NewServer(
            mcp.WithName(name),
            mcp.WithVersion(version),
        ),
        tools: make(map[string]MCPTool),
    }
    return s
}

func (s *MCPServer) RegisterTool(tool MCPTool) {
    s.tools[tool.Name] = tool
    s.server.AddTool(mcp.Tool{
        Name:        tool.Name,
        Description: tool.Description,
        InputSchema: tool.InputSchema,
    }, tool.Handler)
}

// 示例：文件系统工具
func FileSystemTool() MCPTool {
    return MCPTool{
        Name:        "read_file",
        Description: "读取文件内容",
        InputSchema: map[string]interface{}{
            "type": "object",
            "properties": map[string]interface{}{
                "path": map[string]string{
                    "type":        "string",
                    "description": "文件路径",
                },
            },
            "required": []string{"path"},
        },
        Handler: func(args map[string]interface{}) (*mcp.CallToolResult, error) {
            path := args["path"].(string)
            content, err := os.ReadFile(path)
            if err != nil {
                return &mcp.CallToolResult{
                    Content: []mcp.Content{
                        {Type: "text", Text: err.Error()},
                    },
                    IsError: true,
                }, nil
            }
            return &mcp.CallToolResult{
                Content: []mcp.Content{
                    {Type: "text", Text: string(content)},
                },
            }, nil
        },
    }
}

智能聊天机器人 PROJECT

使用 Gin 框架构建支持上下文记忆的 AI 聊天机器人：

go

package main

import (
    "net/http"
    "os"
    "sync"

    "github.com/gin-gonic/gin"
    "github.com/anthropics/anthropic-go"
)

type ChatBot struct {
    client   *anthropic.Client
    sessions map[string][]anthropic.MessageParam
    mu       sync.RWMutex
}

func (b *ChatBot) HandleChat(c *gin.Context) {
    var req struct {
        SessionID string `json:"session_id"`
        Message   string `json:"message"`
    }
    if err := c.ShouldBindJSON(&req); err != nil {
        c.JSON(400, gin.H{"error": err.Error()})
        return
    }

    b.mu.Lock()
    defer b.mu.Unlock()

    messages := b.sessions[req.SessionID]
    messages = append(messages, anthropic.MessageParam{
        Role:    "user",
        Content: req.Message,
    })

    resp, err := b.client.Messages.Create(c,
        anthropic.MessageNewParams{
            Model:     "claude-4-6-haiku-20260325",
            MaxTokens: 1000,
            Messages:  messages,
        })
    if err != nil {
        c.JSON(500, gin.H{"error": err.Error()})
        return
    }

    reply := resp.Content[0].Text
    messages = append(messages, anthropic.MessageParam{
        Role:    "assistant",
        Content: reply,
    })
    b.sessions[req.SessionID] = messages

    c.JSON(200, gin.H{"reply": reply})
}

func main() {
    bot := &ChatBot{
        client:   anthropic.NewClient(os.Getenv("ANTHROPIC_API_KEY")),
        sessions: make(map[string][]anthropic.MessageParam),
    }

    r := gin.Default()
    r.POST("/chat", bot.HandleChat)
    r.Run(":8080")
}

代码助手 PROJECT

基于 Claude 4.6 的智能代码助手，支持代码补全、重构和解释：

go

package main

import (
    "context"
    "fmt"

    "github.com/anthropics/anthropic-go"
)

type CodeAssistant struct {
    client *anthropic.Client
}

func (ca *CodeAssistant) CompleteCode(
    ctx context.Context,
    prompt string,
    language string,
) (string, error) {
    systemPrompt := fmt.Sprintf(
        "你是一个专业的 %s 代码助手。请根据用户的描述生成代码。",
        language,
    )

    resp, err := ca.client.Messages.Create(ctx,
        anthropic.MessageNewParams{
            Model:     "claude-4-6-sonnet-20260325",
            MaxTokens: 2000,
            Messages: []anthropic.MessageParam{
                {
                    Role:    "user",
                    Content: systemPrompt + "\n\n" + prompt,
                },
            },
        })
    if err != nil {
        return "", err
    }

    return resp.Content[0].Text, nil
}

func (ca *CodeAssistant) ExplainCode(
    ctx context.Context,
    code string,
) (string, error) {
    resp, err := ca.client.Messages.Create(ctx,
        anthropic.MessageNewParams{
            Model:     "claude-4-6-sonnet-20260325",
            MaxTokens: 1500,
            Messages: []anthropic.MessageParam{
                {
                    Role:    "user",
                    Content: "请详细解释以下代码的工作原理：\n\n```\n" + code + "\n```",
                },
            },
        })
    if err != nil {
        return "", err
    }

    return resp.Content[0].Text, nil
}

AI 图像生成 PROJECT

使用多模态 AI 实现图像理解和生成：

go

package main

import (
    "context"
    "encoding/base64"
    "os"

    "github.com/anthropics/anthropic-go"
)

type ImageService struct {
    client *anthropic.Client
}

// AnalyzeImage 分析图像内容
func (s *ImageService) AnalyzeImage(
    ctx context.Context,
    imagePath string,
) (string, error) {
    imageData, err := os.ReadFile(imagePath)
    if err != nil {
        return "", err
    }

    base64Image := base64.StdEncoding.EncodeToString(imageData)

    resp, err := s.client.Messages.Create(ctx,
        anthropic.MessageNewParams{
            Model:     "claude-4-6-sonnet-20260325",
            MaxTokens: 1000,
            Messages: []anthropic.MessageParam{
                {
                    Role: "user",
                    Content: []anthropic.ContentBlock{
                        {
                            Type: "image",
                            Source: &anthropic.ImageSource{
                                Type:      "base64",
                                MediaType: "image/png",
                                Data:      base64Image,
                            },
                        },
                        {
                            Type: "text",
                            Text: "请描述这张图片的内容",
                        },
                    },
                },
            },
        })
    if err != nil {
        return "", err
    }

    return resp.Content[0].Text, nil
}