多种编程语言接入大语言模型API指南

在人工智能快速发展的今天，大语言模型(LLM)已成为许多应用的核心技术。本文将详细介绍如何使用多种编程语言接入大语言模型API，以DeepSeek API为例，展示不同语言的实现方式。

介绍

大语言模型API通常提供两种响应模式：

非流式响应(Non-streaming): 等待模型生成完整回答后一次性返回
流式响应(Streaming): 实时返回模型生成的内容，提供更好的用户体验

本文将展示如何使用Python、curl和Golang实现这两种模式的API调用，并在折叠部分提供其他语言的实现方式。

Python实现

Python是接入大语言模型API最常用的语言之一，主要通过官方提供的OpenAI库实现。

标准实现

以下是使用Python OpenAI库的标准实现，支持流式和非流式响应：

# 请先安装OpenAI SDK: `pip3 install openai`

from openai import OpenAI

# 全局配置
STREAM = True  # 设置为True启用流式模式

# 使用DeepSeek API密钥和基础URL初始化客户端
client = OpenAI(
    api_key="sk-your_deepseek_apikey", 
    base_url="https://api.deepseek.com"
)

# 创建聊天完成请求
response = client.chat.completions.create(
    model="deepseek-chat",
    messages=[
        {"role": "system", "content": "You are a helpful assistant"},
        {"role": "user", "content": "Hello"},
    ],
    stream=STREAM
)

# 根据流式模式处理响应
if STREAM:
    # 流式模式需要迭代处理每个数据块
    full_response = ""
    for chunk in response:
        if chunk.choices[0].delta.content is not None:
            content = chunk.choices[0].delta.content
            full_response += content
            print(content, end="", flush=True)
    print()  # 在结尾添加换行
else:
    # 非流式模式直接打印响应
    print(response.choices[0].message.content)

异步实现

对于需要高并发处理的应用，可以使用Python的异步实现：

# 请先安装OpenAI SDK: `pip3 install openai`

import asyncio
from openai import AsyncOpenAI

# 全局配置
STREAM = True  # 设置为True启用流式模式

# 使用DeepSeek API密钥和基础URL初始化异步客户端
client = AsyncOpenAI(
    api_key="sk-your_deepseek_apikey", 
    base_url="https://api.deepseek.com"
)

async def get_completion():
    # 创建聊天完成请求
    response = await client.chat.completions.create(
        model="deepseek-chat",
        messages=[
            {"role": "system", "content": "You are a helpful assistant"},
            {"role": "user", "content": "Tell me about quantum computing"},
        ],
        stream=STREAM
    )
    
    # 根据流式模式处理响应
    if STREAM:
        # 流式模式需要异步迭代处理每个数据块
        full_response = ""
        async for chunk in response:
            if chunk.choices[0].delta.content is not None:
                content = chunk.choices[0].delta.content
                full_response += content
                print(content, end="", flush=True)
        print()  # 在结尾添加换行
        return full_response
    else:
        # 非流式模式直接返回响应
        print(response.choices[0].message.content)
        return response.choices[0].message.content

async def main():
    await get_completion()

# 运行异步函数
if __name__ == "__main__":
    asyncio.run(main())

curl实现

curl是一个命令行工具，可以直接在终端中调用API，非常适合快速测试和调试：

#!/bin/bash

# DeepSeek API 使用 curl 的示例
echo "使用 curl 发送请求到 DeepSeek API..."

curl "https://api.deepseek.com/v1/chat/completions" \
  -H "Content-Type: application/json" \
  -H "Authorization: Bearer sk-your_deepseek_apikey" \
  -d '{
    "model": "deepseek-chat",
    "messages": [
      {
        "role": "user",
        "content": "Write me a haiku about mountains"
      }
    ]
  }'

echo -e "\n\n请求完成！"

要实现流式响应，可以添加stream=true参数：

#!/bin/bash

# DeepSeek API 使用 curl 的流式响应示例
echo "使用 curl 发送流式请求到 DeepSeek API..."

curl "https://api.deepseek.com/v1/chat/completions" \
  -H "Content-Type: application/json" \
  -H "Authorization: Bearer sk-your_deepseek_apikey" \
  -d '{
    "model": "deepseek-chat",
    "messages": [
      {
        "role": "user",
        "content": "Write me a haiku about mountains"
      }
    ],
    "stream": true
  }'

echo -e "\n\n请求完成！"

Golang实现

Golang提供了高性能的API调用实现，使用openai-go库可以轻松实现流式和非流式响应。

非流式实现

package main

import (
	"context"
	"fmt"

	"github.com/openai/openai-go"
	"github.com/openai/openai-go/option"
)

func main() {
	// 创建DeepSeek API客户端
	client := openai.NewClient(
		option.WithAPIKey("sk-your_deepseek_apikey"),
		option.WithBaseURL("https://api.deepseek.com"),
	)

	ctx := context.Background()

	question := "Write me a haiku"

	fmt.Print("> ")
	fmt.Println(question)
	fmt.Println()
	
	params := openai.ChatCompletionNewParams{
		Messages: []openai.ChatCompletionMessageParamUnion{
			openai.UserMessage(question),
		},
		Model: "deepseek-chat",
	}

	completion, err := client.Chat.Completions.New(ctx, params)

	if err != nil {
		panic(err)
	}

	fmt.Println(completion.Choices[0].Message.Content)
}

流式实现

package main

import (
	"context"
	"fmt"

	"github.com/openai/openai-go"
	"github.com/openai/openai-go/option"
)

func main() {
	// 创建DeepSeek API客户端
	client := openai.NewClient(
		option.WithAPIKey("sk-your_deepseek_apikey"),
		option.WithBaseURL("https://api.deepseek.com"),
	)

	ctx := context.Background()

	question := "Write me a haiku"

	fmt.Print("> ")
	fmt.Println(question)
	fmt.Println()

	stream := client.Chat.Completions.NewStreaming(ctx, openai.ChatCompletionNewParams{
		Messages: []openai.ChatCompletionMessageParamUnion{
			openai.UserMessage(question),
		},
		Model: "deepseek-chat",
	})

	for stream.Next() {
		evt := stream.Current()
		if len(evt.Choices) > 0 {
			fmt.Print(evt.Choices[0].Delta.Content)
		}
	}
	fmt.Println()

	if err := stream.Err(); err != nil {
		panic(err.Error())
	}
}

其他语言实现

Node.js实现

Node.js可以使用内置的fetch API或第三方库调用大语言模型API：

// 使用 Node.js 的 fetch API 发送请求到 DeepSeek API

async function getCompletion() {
    console.log("使用 Node.js fetch API 发送请求到 DeepSeek API...");
    
    const apiKey = "sk-your_deepseek_apikey";
    const url = "https://api.deepseek.com/v1/chat/completions";
    
    const response = await fetch(url, {
        method: "POST",
        headers: {
            "Content-Type": "application/json",
            "Authorization": `Bearer ${apiKey}`
        },
        body: JSON.stringify({
            model: "deepseek-chat",
            messages: [
                {
                    role: "user",
                    content: "Write me a haiku about oceans"
                }
            ]
        })
    });
    
    const data = await response.json();
    
    // 打印完整的JSON响应
    console.log("\n完整响应:");
    console.log(JSON.stringify(data, null, 2));
    
    // 只打印生成的内容
    console.log("\n生成的内容:");
    console.log(data.choices[0].message.content);
    
    return data;
}

// 运行异步函数
getCompletion()
    .then(() => console.log("\n请求完成！"))
    .catch(error => console.error("发生错误:", error));

Rust实现

Rust可以使用reqwest库实现API调用：

use reqwest;
use serde::{Deserialize, Serialize};
use serde_json::{json, Value};

#[derive(Serialize, Deserialize, Debug)]
struct Message {
    role: String,
    content: String,
}

#[derive(Serialize, Deserialize, Debug)]
struct RequestBody {
    model: String,
    messages: Vec<Message>,
}

#[tokio::main]
async fn main() -> Result<(), Box<dyn std::error::Error>> {
    let client = reqwest::Client::new();
    
    let request_body = RequestBody {
        model: "deepseek-chat".to_string(),
        messages: vec![
            Message {
                role: "user".to_string(),
                content: "Write me a haiku about mountains".to_string(),
            },
        ],
    };
    
    let response = client
        .post("https://api.deepseek.com/v1/chat/completions")
        .header("Content-Type", "application/json")
        .header("Authorization", "Bearer sk-your_deepseek_apikey")
        .json(&request_body)
        .send()
        .await?;
    
    let json: Value = response.json().await?;
    println!("{}", json["choices"][0]["message"]["content"]);
    
    Ok(())
}

总结

本文介绍了使用Python、curl和Golang接入大语言模型API的多种方式，包括流式和非流式响应处理。无论您选择哪种编程语言，都可以轻松地将大语言模型集成到您的应用中。

选择合适的实现方式取决于您的具体需求：

快速原型开发和测试：使用Python或curl
高性能服务：考虑Golang或异步Python
前端应用：可以使用JavaScript/Node.js

希望本文对您接入大语言模型API有所帮助！

介绍#

Python实现#

标准实现#

异步实现#

curl实现#

Golang实现#

非流式实现#

流式实现#

Node.js实现#

Rust实现#

总结#

参考资料#

介绍