✨ 特性

• 使用任意提供商：内置连接器支持：阿里巴巴、Anthropic、Azure、Blablador、Cohere、DeepInfra、DeepSeek、Google、Groq、MiniMax、Mistral、MoonshotAI、OpenAI、OpenRouter、Perplexity、Requesty、Upstage、Voyage、xAI、Z.ai等。这些连接器通过强类型代码暴露所有细分和独特的功能，并始终紧跟最新的AI发展。无需依赖任何第一方SDK。特性矩阵详细记录了对各个端点的支持情况。
• 一流的本地部署：可通过集成的请求转换支持，与vLLM、Ollama或LocalAI一起运行。
• 智能体编排：借助三个核心概念——Orchestrator（图）、Runner（节点）和Advancer（边）——协调专业智能体，使其能够自主执行复杂任务。提供交接机制、并行执行、Mermaid导出以及构建者模式，让操作更加简单。
• 快速开发：只需编写一次管道，通过更改模型名称即可在任何提供商上执行。将您的编辑器连接到Context7或FSKB，即可通过即时访问向量化文档来加速编码。
• 完全多模态：支持文本、图像、视频、文档、URL和音频的输入与输出。
• 前沿协议：
  • MCP：通过LlmTornado.Mcp，利用模型上下文协议将智能体连接到数据源、工具和工作流。
  • A2A：借助LlmTornado.A2A，实现跨不同平台的AI智能体之间的无缝协作。
  • 技能：动态加载指令、脚本和资源文件夹，以提升特定任务的性能。
• 向量数据库：内置连接器支持Chroma、PgVector、Pinecone、Faiss和QDrant。
• 集成性：与Microsoft.Extensions.AI的互操作性使Tornado能够通过LlmTornado.Microsoft.Extensions.AI插入到Semantic Kernel应用中。
• 企业级就绪：配备护栏框架，在提交请求之前可对其进行预览和转换。支持Open Telemetry。稳定的API。

🔥 2026年新闻

• 2月26日 - 实现了MiniMax连接器。新增压缩端点，可与LLM Tornado内置的压缩功能协同使用。开始着手开发ACP。
• 1月26日 - Ivy Framework使用LlmTornado.Agents构建其AI组件。为Mistral实现了/ocr端点。对所有支持的提供商扩展了/files端点支持。

新闻 2025

• 25/12 - 实现了 Upstage 连接器。为 OpenAI、Anthropic 和 Google 实现了 /batch 端点。/videos 端点现在支持 OpenAI/Sora。
• 25/11 - Flowbite Blazor 使用 LLM Tornado 构建了他们的 AI 聊天 WASM 组件。实现了 Requesty 连接器。为所有支持该功能的提供商实现了 /tokenize 端点。
• 25/10 - LLM Tornado 被 JetBrains 收录于 dotInsights。Microsoft 在 面向初学者的 .NET 生成式 AI 中使用了 LLM Tornado。与 Microsoft.Extensions.AI 的互操作性正式推出。实现了 Skills 协议。
• 25/09 - 维护者 Matěj Štágl 和 John Lomba 在 .NET AI 社区站会 中讨论了 LLM Tornado。实现了 PgVector 和 ChromaDb 连接器。
• 25/08 - ProseFlow 是用 LLM Tornado 构建的。Sciobot——一个由 LLM Tornado 构建的教育者用 AI 平台，已被 Cohere Labs 催化器资助计划 接受。实现了 A2A 协议。
• 25/07 - 贡献者 Shaltiel Shmidman 在 Asp.net 社区站会 中谈到了 LLM Tornado。新增了对 Z.ai、阿里巴巴 和 Blablador 的连接器。
• 25/06 - 添加了 C# 委托作为代理工具 系统，使应用程序无需手动编写 JSON 模式。实现了 MCP 协议。
• 25/05 - 添加了 聊天转响应 系统，允许从 /chat 端点使用 /responses 专属模型。
• 25/04 - 新增了对 DeepInfra、DeepSeek 和 Perplexity 的连接器。
• 25/03 - 实现了 助手 功能。
• 25/02 - 新增了对 OpenRouter、Voyage 和 xAI 的连接器。
• 25/01 - 实现了严格 JSON 模式，新增了 Groq 和 Mistral 连接器。

⭐ 示例

• 与你的文档聊天
• 制作多说话人播客
• 使用麦克风与 AI 进行语音通话
• 编排助手
• 生成图片
• 总结视频（本地文件 / YouTube）
• 将文本和图片转换为高质量嵌入
• 实时转录音频

⚡ 入门指南

通过 NuGet 安装 LLM Tornado：

dotnet add package LlmTornado

可选插件：

dotnet add package LlmTornado.Agents # 代理框架，更高层次的抽象
dotnet add package LlmTornado.Mcp # 模型上下文协议 (MCP) 集成
dotnet add package LlmTornado.A2A # 代理间交互 (A2A) 集成
dotnet add package LlmTornado.Microsoft.Extensions.AI # 语义核互操作性
dotnet add package LlmTornado.Contrib # 提高生产力和生活质量的增强功能

🪄 快速推理

在多个提供商之间进行推理非常简单，只需更改 ChatModel 参数即可。Tornado 实例可以使用多个 API 密钥构建，系统会根据模型自动选择正确的密钥：

TornadoApi api = new TornadoApi([
    // 注意：删除你不会使用的提供商对应的行
    new (LLmProviders.OpenAi, "OPEN_AI_KEY"),
    new (LLmProviders.Anthropic, "ANTHROPIC_KEY"),
    new (LLmProviders.Cohere, "COHERE_KEY"),
    new (LLmProviders.Google, "GOOGLE_KEY"),
    new (LLmProviders.Groq, "GROQ_KEY"),
    new (LLmProviders.DeepSeek, "DEEP_SEEK_KEY"),
    new (LLmProviders.Mistral, "MISTRAL_KEY"),
    new (LLmProviders.XAi, "XAI_KEY"),
    new (LLmProviders.Perplexity, "PERPLEXITY_KEY"),
    new (LLmProviders.Voyage, "VOYAGE_KEY"),
    new (LLmProviders.DeepInfra, "DEEP_INFRA_KEY"),
    new (LLmProviders.OpenRouter, "OPEN_ROUTER_KEY")
]);

// 此示例遍历多个模型，给每个模型相同的任务，并打印结果。
List<ChatModel> models = [
    ChatModel.OpenAi.O3.Mini, ChatModel.Anthropic.Claude37.Sonnet,
    ChatModel.Cohere.Command.RPlus, ChatModel.Google.Gemini.Gemini2Flash001,
    ChatModel.Groq.Meta.Llama370B, ChatModel.DeepSeek.Models.Chat,
    ChatModel.Mistral.Premier.MistralLarge, ChatModel.XAi.Grok.Grok2241212,
    ChatModel.Perplexity.Sonar.Default
];

foreach (ChatModel model in models)
{
    string? response = await api.Chat.CreateConversation(model)
        .AppendSystemMessage("你是一位算命师。")
        .AppendUserInput("我的未来会怎样？")
        .GetResponse();

    Console.WriteLine(response);
}

💡 除了传递强类型模型外，你也可以直接传入字符串：await api.Chat.CreateConversation("gpt-5-mini")，Tornado 会自动解析提供商。

❄️ 供应商扩展

Tornado 拥有一个强大的 VendorExtensions 概念，可以应用于各种端点，并且是强类型的。许多提供商都提供独特或小众的 API，通常能够实现其他方式无法实现的用例。例如，我们可以为 Anthropic 的 Claude 3.7 设置推理预算：

public static async Task AnthropicSonnet37Thinking()
{
    Conversation chat = Program.Connect(LLmProviders.Anthropic).Chat.CreateConversation(new ChatRequest
    {
        Model = ChatModel.Anthropic.Claude37.Sonnet,
        VendorExtensions = new ChatRequestVendorExtensions(new ChatRequestVendorAnthropicExtensions
        {
            Thinking = new AnthropicThinkingSettings
            {
                BudgetTokens = 2_000,
                Enabled = true
            }
        })
    });
    
    chat.AppendUserInput("解释如何解微分方程。");

    ChatRichResponse blocks = await chat.GetResponseRich();

    if (blocks.Blocks is not null)
    {
        foreach (ChatRichResponseBlock reasoning in blocks.Blocks.Where(x => x.Type is ChatRichResponseBlockTypes.Reasoning))
        {
            Console.ForegroundColor = ConsoleColor.DarkGray;
            Console.WriteLine(reasoning.Reasoning?.Content);
            Console.ResetColor();
        }

        foreach (ChatRichResponseBlock reasoning in blocks.Blocks.Where(x => x.Type is ChatRichResponseBlockTypes.Message))
        {
            Console.WriteLine(reasoning.Message);
        }
    }
}

🔮 自托管/自定义提供商

除了使用商业 API 外，用户还可以借助 大量可用工具轻松搭建自己的推理服务器。以下是一个使用 Ollama 进行流式响应的简单示例，但同样的方法也可用于任何自定义提供商：

public static async Task OllamaStreaming()
{
    TornadoApi api = new TornadoApi(new Uri("http://localhost:11434")); // 默认 Ollama 端口，如有需要可在第二个参数中传入 API 密钥
    
    await api.Chat.CreateConversation(new ChatModel("falcon3:1b")) // <-- 替换为您使用的模型
        .AppendUserInput("为什么天空是蓝色的？")
        .StreamResponse(Console.Write);
}

如果需要对请求有更多控制，比如添加自定义头部信息，可以创建一个内置提供商的实例。这对于 Amazon Bedrock、Vertex AI 等自定义部署非常有用。

TornadoApi tornadoApi = new TornadoApi(new AnthropicEndpointProvider
{
    Auth = new ProviderAuthentication("ANTHROPIC_API_KEY"),
    // {0} = 端点, {1} = 操作, {2} = 模型名称
    UrlResolver = (endpoint, url, ctx) => "https://api.anthropic.com/v1/{0}{1}",
    RequestResolver = (request, data, streaming) =>
    {
        // 默认情况下，提供自定义请求解析器会忽略 beta 头部
        // request 是 HttpRequestMessage，data 包含有效载荷
    },
    RequestSerializer = (data, ctx) =>
    {
       // data 是 JObject，可以在序列化为字符串之前进行修改。
    }
});

https://github.com/user-attachments/assets/de62f0fe-93e0-448c-81d0-8ab7447ad780

🔎 高级推理

流式处理

Tornado 提供了三个抽象层次，细节越多，复杂性也越高。对于只需要纯文本的简单场景，可以用简洁的格式表示：

await api.Chat.CreateConversation(ChatModel.Anthropic.Claude3.Sonnet)
    .AppendSystemMessage("你是一位算命师。")
    .AppendUserInput("我的未来会怎样？")
    .StreamResponse(Console.Write);

抽象层次如下：

• Response（聊天为 string，嵌入为 float[] 等）
• ResponseRich（工具、模态、用量等元数据）
• ResponseRichSafe（与第 2 层相同，但在网络层面不会抛出异常，例如当提供商返回内部错误或完全无响应时）

带丰富内容的流式处理（工具、图像、音频等）

当纯文本不足以满足需求时，可以切换到 StreamResponseRich 或 GetResponseRich() API。模型请求的工具可以在稍后解析，而无需再返回给模型。这在我们使用工具但不打算继续对话的情况下非常有用：

// 请求模型生成两张图片，并流式输出结果：
public static async Task GoogleStreamImages()
{
    Conversation chat = api.Chat.CreateConversation(new ChatRequest
    {
        Model = ChatModel.Google.GeminiExperimental.Gemini2FlashImageGeneration,
        Modalities = [ ChatModelModalities.Text, ChatModelModalities.Image ]
    });
    
    chat.AppendUserInput([
        new ChatMessagePart("生成两张图片：一头狮子和一只松鼠")
    ]);
    
    await chat.StreamResponseRich(new ChatStreamEventHandler
    {
        MessagePartHandler = async (part) =>
        {
            if (part.Text is not null)
            {
                Console.Write(part.Text);
                return;
            }

            if (part.Image is not null)
            {
                // 在我们的测试中，这里会调用 Chafa 将原始 base64 数据转换为 Sixels 格式
                await DisplayImage(part.Image.Url);
            }
        },
        BlockFinishedHandler = (block) =>
        {
            Console.WriteLine();
            return ValueTask.CompletedTask;
        },
        OnUsageReceived = (usage) =>
        {
            Console.WriteLine();
            Console.WriteLine(usage);
            return ValueTask.CompletedTask;
        }
    });
}

工具即时解析

模型请求的工具可以立即解析并返回结果。这样做的好处是可以自动继续对话：

Conversation chat = api.Chat.CreateConversation(new ChatRequest
{
    Model = ChatModel.OpenAi.Gpt4.O,
    Tools =
    [
        new Tool(new ToolFunction("get_weather", "获取当前天气", new
        {
            type = "object",
            properties = new
            {
                location = new
                {
                    type = "string",
                    description = "需要查询天气信息的位置。"
                }
            },
            required = new List<string> { "location" }
        }))
    ]
})
.AppendSystemMessage("你是一位乐于助人的助手")
.AppendUserInput("今天布拉格的天气怎么样？");

ChatStreamEventHandler handler = new ChatStreamEventHandler
{
  MessageTokenHandler = (x) =>
  {
      Console.Write(x);
      return Task.CompletedTask;
  },
  FunctionCallHandler = (calls) =>
  {
      calls.ForEach(x => x.Result = new FunctionResult(x, "预计中午前后会有小雨。", null));
      return Task.CompletedTask;
  },
  AfterFunctionCallsResolvedHandler = async (results, handler) => { await chat.StreamResponseRich(handler); }
};

await chat.StreamResponseRich(handler);

延迟解析的工具

我们也可以不解析工具调用，而是推迟或结束对话。这对于提取类任务非常有用，因为我们只关心工具调用：

Conversation chat = api.Chat.CreateConversation(new ChatRequest
{
    Model = ChatModel.OpenAi.Gpt4.Turbo,
    Tools = new List<Tool>
    {
        new Tool
        {
            Function = new ToolFunction("get_weather", "获取当前天气")
        }
    },
    ToolChoice = new OutboundToolChoice(OutboundToolChoiceModes.Required)
});

chat.AppendUserInput("你是谁？"); // 用户提出了无关问题，但我们强制模型使用工具
ChatRichResponse response = await chat.GetResponseRich(); // 响应包含一个函数类型的块

GetResponseRichSafe() API 也可用，它保证不会在网络层面抛出异常。响应被封装在一个包含额外信息的网络层包装器中。对于生产环境中的用例，可以在所有产生 HTTP 请求的 Tornado API 上使用 try {} catch {} 结构，或者直接使用安全的 API。

🌐 MCP

要使用模型上下文协议，需安装 LlmTornado.Mcp 适配器。安装后，ModelContextProtocol 类型上将提供新的互操作方法。以下示例使用了在 示例 MCP 服务器 上定义的 GetForecast 工具：

[McpServerToolType]
public sealed class WeatherTools
{
    [McpServerTool, Description("获取某个地点的天气预报。")]
    public static async Task<string> GetForecast(
        HttpClient client,
        [Description("地点的纬度。")] double latitude,
        [Description("地点的经度。")] double longitude)
    {
        var pointUrl = string.Create(CultureInfo.InvariantCulture, $"/points/{latitude},{longitude}");
        using var jsonDocument = await client.ReadJsonDocumentAsync(pointUrl);
        var forecastUrl = jsonDocument.RootElement.GetProperty("properties").GetProperty("forecast").GetString()
            ?? throw new Exception($"No forecast URL provided by {client.BaseAddress}points/{latitude},{longitude}");

        using var forecastDocument = await client.ReadJsonDocumentAsync(forecastUrl);
        var periods = forecastDocument.RootElement.GetProperty("properties").GetProperty("periods").EnumerateArray();

        return string.Join("\n---\n", periods.Select(period => $"""
                {period.GetProperty("name").GetString()}
                温度: {period.GetProperty("temperature").GetInt32()}°F
                风速: {period.GetProperty("windSpeed").GetString()} {period.GetProperty("windDirection").GetString()}
                天气预报: {period.GetProperty("detailedForecast").GetString()}
                """));
    }
}

客户端需要执行以下操作：

// 您的客户端传输方式，例如 StdioClientTransport
await using IMcpClient mcpClient = await McpClientFactory.CreateAsync(clientTransport);

// 1. 获取工具列表
List<Tool> tools = await mcpClient.ListTornadoToolsAsync();

// 2. 创建对话，并传递可用工具
TornadoApi api = new TornadoApi(LLmProviders.OpenAi, apiKeys.OpenAi);
Conversation conversation = api.Chat.CreateConversation(new ChatRequest
{
    Model = ChatModel.OpenAi.Gpt41.V41,
    Tools = tools,
    // 强制使用任意一个可用工具（如果需要指定具体工具，可使用 new OutboundToolChoice("toolName")）
    ToolChoice = OutboundToolChoice.Required
});

// 3. 让模型调用工具并推断参数
await conversation
    .AddSystemMessage("您是一位有用的助手")
    .AddUserMessage("达拉斯现在的天气如何？")
    .GetResponseRich(async calls =>
    {
        foreach (FunctionCall call in calls)
        {
            // 获取模型推断出的参数
            double latitude = call.GetOrDefault<double>("latitude");
            double longitude = call.GetOrDefault<double>("longitude");
            
            // 在 MCP 服务器上调用工具，并传递参数
            await call.ResolveRemote(new
            {
                latitude = latitude,
                longitude = longitude
            });

            // 提取工具返回的结果，并将其传递回模型
            if (call.Result?.RemoteContent is McpContent mcpContent)
            {
                foreach (IMcpContentBlock block in mcpContent.McpContentBlocks)
                {
                    if (block is McpContentBlockText textBlock)
                    {
                        call.Result.Content = textBlock.Text;
                    }
                }
            }
        }
    });

// 取消对客户端调用工具的强制要求
conversation.RequestParameters.ToolChoice = null;

// 4. 流式输出最终响应
await conversation.StreamResponse(Console.Write);

完整的示例可在以下位置找到：客户端，服务器。

🧰 工具包

Tornado 在 LlmTornado.Toolkit 包中提供了强大的抽象层，能够帮助开发者快速构建应用，同时避免许多设计陷阱。这些抽象的核心在于代码的可扩展性和易于调优的设计。

ToolkitChat

ToolkitChat 是一种基于图的工作流原语，其中边负责传递数据，节点则执行函数。ToolkitChat 支持流式处理、丰富响应以及工具调用的链式操作。工具调用可以通过 ChatFunction 或 ChatPlugin（一个包含多个工具的封装）来提供。许多重载方法接受主模型和备用模型，这种交错策略比简单地重试同一模型更能有效应对 API 的临时中断。所有工具调用都是强类型的，默认为“严格”模式。对于不支持严格 JSON 模式的提供商（例如 Anthropic），会使用 { 进行预填充作为回退方案。只需更改参数即可将调用标记为“非严格”。

class DemoAggregatedItem
{
    public string Name { get; set; }
    public string KnownName { get; set; }
    public int Quantity { get; set; }
}

string sysPrompt = "按类型汇总物品";
string userPrompt = "三个苹果，一个樱桃，两个苹果，一个橙子，一个橙子";

await ToolkitChat.GetSingleResponse(Program.Connect(), ChatModel.Google.Gemini.Gemini25Flash, ChatModel.OpenAi.Gpt41.V41Mini, sysPrompt, new ChatFunction([
    new ToolParam("items", new ToolParamList("汇总后的物品", [
        new ToolParam("name", "物品名称", ToolParamAtomicTypes.String),
        new ToolParam("quantity", "汇总数量", ToolParamAtomicTypes.Int),
        new ToolParam("known_name", new ToolParamEnum("物品已知名称", [ "苹果", "樱桃", "橙子", "其他" ]))
    ]))
], async (args, ctx) =>
{
    if (!args.ParamTryGet("items", out List<DemoAggregatedItem>? items) || items is null)
    {
        return new ChatFunctionCallResult(ChatFunctionCallResultParameterErrors.MissingRequiredParameter, "items");
    }
    
    Console.WriteLine("汇总后的物品：");

    foreach (DemoAggregatedItem item in items)
    {
        Console.WriteLine($"{item.Name}: {item.Quantity}");
    }
    
    return new ChatFunctionCallResult();
}), userPrompt); // 温度默认为 0，输出长度为 8k

/*
汇总后的物品：
苹果：5
樱桃：1
橙子：2
*/

👉 为什么选择 Tornado？

• 在 NuGet 上拥有超过 10 万次安装。
• 被用于获奖的商业项目中，每月处理超过 1000 亿个 token。
• 覆盖了 500 多项测试。
• 性能优异。
• 许可证永远不会改变。

📢 使用 Tornado 构建的项目

• ScioBot - 面向教育者的 AI 工具，用户超过 10 万人。
• ProseFlow - 您的通用 AI 文本处理器，由本地和云端 LLM 提供支持。可在 Windows、macOS 和 Linux 上的任何应用程序中编辑、重构和转换文本。
• NotT3Chat - C# 版本的 T3 堆栈解决方案。
• ClaudeCodeProxy - 提供商多路复用代理。
• Semantic Search - 基于上下文和语义匹配查询的 AI 语义搜索。

您是否使用 Tornado 构建过项目？请在 Issues 中告诉我们，我们将为您展示！

🤝 合作伙伴

赞助方

技术支持

📚 贡献

我们欢迎 PR！目前正在接受新的提供商实现、对 100% 绿色功能矩阵的贡献，以及在公开讨论后提出的新抽象概念。

星标历史

许可证

本库采用 MIT 许可证授权。💜

LLMTornado 快速上手指南

LLM Tornado 是一个专为 .NET 开发者设计的提供商无关 SDK，助你在几分钟内构建、编排和部署 AI 智能体（Agents）与工作流。它内置了 30+ 主流 AI 模型提供商（包括阿里云、DeepSeek、月之暗面等）和向量数据库的连接器，无需依赖各家的官方 SDK 即可使用其最新特性。

环境准备

在开始之前，请确保你的开发环境满足以下要求：

• 操作系统: Windows, Linux, 或 macOS
• .NET SDK: 版本 .NET 8.0 或更高版本
• 开发工具: Visual Studio 2022, JetBrains Rider, 或 VS Code (推荐安装 C# Dev Kit 扩展)
• API 密钥: 至少拥有一个支持的 AI 服务提供商的 API Key（如 OpenAI, Azure OpenAI, 阿里云百炼，DeepSeek 等）

安装步骤

通过 NuGet 包管理器将 LLMTornado 添加到你的 .NET 项目中。

1. 安装核心库

打开终端或包管理器控制台，运行以下命令安装基础包：

dotnet add package LlmTornado

2. 可选扩展包

根据项目需求，你可以选择安装以下功能扩展包：

# 智能体编排框架（高阶抽象，推荐用于复杂任务）
dotnet add package LlmTornado.Agents

# Model Context Protocol (MCP) 集成，用于连接数据源和工具
dotnet add package LlmTornado.Mcp

# Agent2Agent (A2A) 集成，实现跨平台智能体协作
dotnet add package LlmTornado.A2A

# 与 Microsoft.Extensions.AI 及 Semantic Kernel 互操作
dotnet add package LlmTornado.Microsoft.Extensions.AI

# 生产力增强工具
dotnet add package LlmTornado.Contrib

提示：国内开发者若遇到 NuGet 下载缓慢，可临时指定国内镜像源： dotnet add package LlmTornado --source https://api.nuget.org/v3/index.json (通常自动生效，若需强制指定可用 https://www.myget.org/F/azure-appservice/api/v3/index.json 或其他国内私有源配置)

基本使用

LLM Tornado 的核心优势在于统一接口。你只需初始化一次 TornadoApi 实例并配置多个提供商的密钥，后续只需更改模型名称即可切换底层提供商，无需修改业务逻辑代码。

最简单的推理示例

以下示例展示了如何配置多个提供商并进行一次简单的聊天调用：

using LlmTornado;
using LlmTornado.Chat;

// 1. 初始化 API 客户端
// 支持同时传入多个提供商的 Key，系统会根据调用的模型自动匹配正确的 Key
TornadoApi api = new TornadoApi([
    new (LLmProviders.OpenAi, "YOUR_OPENAI_KEY"),
    new (LLmProviders.Anthropic, "YOUR_ANTHROPIC_KEY"),
    new (LLmProviders.DeepSeek, "YOUR_DEEPSEEK_KEY"), // 支持国产模型
    new (LLmProviders.AliCloud, "YOUR_ALICLOUD_KEY"), // 支持阿里云
    // 添加更多你需要的提供商...
]);

// 2. 执行聊天请求
// 只需更改 model 参数即可切换提供商，例如从 "gpt-4o" 切换到 "deepseek-chat"
var response = await api.Chat.GetChatCompletion(new ChatRequest()
{
    Model = "gpt-4o", // 尝试改为 "deepseek-chat" 或 "qwen-plus" 测试不同模型
    Messages = [
        new(ChatMessageRole.System, "你是一个乐于助人的 AI 助手。"),
        new(ChatMessageRole.User, "你好，请介绍一下你自己。")
    ]
});

// 3. 输出结果
Console.WriteLine(response.FirstChoice.Message.Content);

关键特性说明

• 自动路由: TornadoApi 会自动识别 Model 字符串所属的提供商，并调用对应的 API 端点和密钥。
• 强类型支持: 所有提供商的特有功能（如 JSON Mode, Vision, Function Calling）均通过强类型代码暴露，享受完整的 IntelliSense 支持。
• 本地部署: 同样支持连接本地的 vLLM, Ollama 或 LocalAI，只需在初始化时配置相应的 Base URL 即可。

现在你可以开始探索更高级的功能，如智能体编排（Agents Orchestration）、RAG 向量检索或多模态处理了。