Ferramentas para chamar a axentes de IA locais en C#

As ferramentas son unha parte fundamental da IA axente, xunto con estas capacidades básicas: Mentres que os modelos de linguaxe excelen na comprensión e xeración de texto, as ferramentas estenden as súas habilidades ao permitir que interactúen co mundo real: buscar a web para a información actual, executar código para cálculos, acceder a bases de datos, ler ficheiros ou conectarse a servizos externos a través de APIs. Pense en ferramentas como as mans e os ollos dun axente de IA. Transforman un sistema de conversación nun axente que pode realizar tarefas ponteando a brecha entre o razoamento e a acción. Cando un axente necesita comprobar o tempo, analizar unha folla de cálculo ou enviar un correo electrónico, invoca a ferramenta adecuada, recibe o resultado e incorpora esa información na súa resposta. Interesado en como os axentes conservan e usan o contexto ao longo do tempo? . Axente de memoria Por que os axentes locais foron duros Construír axentes de IA que poden realmente facer cousas localmente foi sorprendentemente difícil. Modelos que entenden cando e como chamar funcións externas Privacidade sen enviar datos á nube Un tempo de execución que pode analizar as chamadas de ferramentas, validar argumentos e inxectar resultados Fluxos específicos de modelo porque cada modelo ten diferentes formatos de chamada de ferramentas e patróns de interacción, requirindo lóxica personalizada para intercepción, inxección de resultados e orde de acción Controles de seguridade para evitar circuítos infinitos e custos de fuga Observación clara para que saiba o que está a facer o seu axente Ata agora, a maioría dos marcos de axentes forzaban unha elección: poderosos axentes baseados na nube con preocupacións de latencia e privacidade, ou modelos locais limitados sen o soporte adecuado das ferramentas. Por que a ferramenta Chamando cambia todo Coas novas capacidades de chamada de ferramentas de LM-Kit, os seus axentes locais poden: Respostas de terra en datos reais. Non máis previsións meteorolóxicas alucinadas ou taxas de cambio. Os axentes obteñen respostas de API reais e poden citar fontes. Fluxos de traballo complexos en cadea. Por exemplo: verifique o tempo, converta a temperatura ás unidades preferidas do usuario e, a continuación, suxire actividades. Manter a privacidade completa. Todo funciona no dispositivo. As consultas dos usuarios, os argumentos de ferramentas e os resultados nunca deixan as súas máquinas. Permanecer determinista e seguro. esquemas escritos, entradas validadas, controis de políticas e ganchos de aprobación impiden que os axentes sexan falsos. Engade APIs empresariais, bases de datos internas ou catálogos de MCP externos como ferramentas.O modelo aprende a usalos a partir de descricións e esquemas soamente. O que é novo a unha ollada Os modelos deciden cando chamar ferramentas, pasan args de JSON estruturados e usan os resultados para responder aos usuarios con precisión. Soporte de fluxo dedicado a familias de modelos como Mistral, GPT-OSS, Qwen, Granite, LLaMA e máis, todo a través dun só tempo de execución. Three ways to add tools: Implement ITool Annotate methods with [LMFunction] Import catalogs from MCP servers API unificada que executa SLMs locais con políticas per-turn, gardrails e eventos para humano-in-the-loop e observabilidade en cada etapa. Todos os modos de chamada de funcións son compatibles. Función simple, función múltiple, función paralela e función múltiple paralela, escoller secuenciación estrita ou paralelismo seguro. Os SLM modernos emiten chamadas de ferramentas estruturadas. LM-Kit analiza as chamadas, encamiña as súas ferramentas e alimenta os resultados con correlacións e tipos de resultados claros para un camiño de inferencia fiable. Como funciona: Comezando Aquí tes un exemplo de traballo completo en menos de 20 liñas: using LMKit.Model; using LMKit.TextGeneration; using LMKit.Agents.Tools; using System.Text.Json; // 1) Load a local model from the catalog var model = LM.LoadFromModelID("gptoss:20b"); // OpenAI GPT-OSS 20B // Optional: confirm tool-calling capability if (!model.HasToolCalls) { /* choose a different model or fallback */ } // 2) Create a multi-turn conversation using var chat = new MultiTurnConversation(model); // 3) Register tools (see three options below) chat.Tools.Register(new WeatherTool()); // 4) Shape the behavior per turn chat.ToolPolicy.Choice = ToolChoice.Auto; // let the model decide chat.ToolPolicy.MaxCallsPerTurn = 3; // guard against loops // 5) Ask a question var reply = chat.Submit("Plan my weekend and check the weather in Toulouse."); Console.WriteLine(reply.Content); O catálogo de modelos inclúe GPT-OSS e moitas outras familias. Deseña unha tarxeta nomeada como Tamén podes comprobar antes de confiar nas ferramentas. LM.LoadFromModelID gptoss:20b HasToolCalls Vexa o Para os detalles. Documentación do catálogo Probe agora: mostra de GitHub Unha mostra de consola preparada para a produción demostra chat multi-turn con chamada de ferramentas (moeda, clima, conversión de unidade), políticas por turno, retroalimentación do progreso e comandos especiais. Create Multi-Turn Chatbot with Tools in .NET Applications Creación de chatbots multi-turn con ferramentas en aplicacións .NET Tres xeitos de engadir ferramentas Implementación de ITool (Control completo) Mellor cando precisa contratos claros e validación personalizada. Esta páxina mostra a implementación do En canto ao uso das ferramentas, as ferramentas poden ser utilizadas para a súa utilización. ( , , ), parsa JSON args, executa a súa lóxica e devolve JSON estruturado ao modelo. ITool Name Description InputSchema public sealed class WeatherTool : ITool { public string Name => "get_weather"; public string Description => "Get current weather for a city. Returns temperature, conditions, and optional hourly forecast."; // JSON Schema defines expected arguments public string InputSchema => """ { "type": "object", "properties": { "city": {"type": "string", "description": "City name (e.g., 'Paris' or 'New York')"} }, "required": ["city"] } """; public async Task InvokeAsync(string arguments, CancellationToken ct = default) { // Parse the model's JSON arguments var city = JsonDocument.Parse(arguments).RootElement.GetProperty("city").GetString(); // Call your weather API var weatherData = await FetchWeatherAsync(city); // Return structured JSON the model can understand var result = new { city, temp_c = weatherData.Temp, conditions = weatherData.Conditions }; return JsonSerializer.Serialize(result); } } // Register it chat.Tools.Register(new WeatherTool()); Control completo sobre a validación, a execución asínc, o manexo de erros e a formatación de resultados. Why use ITool? 2) Anotando métodos con [LMFunción] (Binding rápido) Mellor para prototipos rápidos e ferramentas sinxelas. What it does: Add LM-Kit descobre e expón cada un deles como un , xerando un esquema JSON a partir de parámetros de método. [LMFunction(name, description)] ITool Como é cableado: Reflexionar e conectar con ou / ), logo rexistra as ferramentas resultantes a través . LMFunctionToolBinder.FromType () FromInstance FromAssembly chat.Tools.Register(...) public sealed class MyDomainTools { [LMFunction("search_docs", "Search internal documentation by keyword. Returns top 5 matches.")] public string SearchDocs(string query) { var results = _documentIndex.Search(query).Take(5); return JsonSerializer.Serialize(new { hits = results }); } [LMFunction("get_user_info", "Retrieve user profile and preferences.")] public string GetUserInfo(int userId) { var user = _database.GetUser(userId); return JsonSerializer.Serialize(user); } } // Automatically scan and register all annotated methods var tools = LMFunctionToolBinder.FromType (); chat.Tools.Register(tools); Menos carballo, máis Xera esquemas a partir de tipos de parámetros e rexistra todo nunha liña. Why use [LMFunction]? Ligazón Importar catálogos de MCP (servizos externos) Mellor para conectarse a ecosistemas de ferramentas de terceiros a través do Protocolo de Contexto Modelo. O que fai: Uso Para establecer unha sesión JSON-RPC cun servidor MCP, colle o seu catálogo de ferramentas e adapte esas ferramentas para que o seu axente poida chamalas. mcclient Como se fai: Crear (opcional configurar un token de portador), entón para importar o catálogo; LM-Kit xestiona , Retiros e persistencia de sesións. new McpClient(uri, httpClient) chat.Tools.Register(mcp, overwrite: false) tools/list tools/call using LMKit.Mcp.Client; // Connect to an MCP server var mcp = new McpClient( new Uri("https://mcp.example.com/api"), new HttpClient() ); // Import all available tools from the server int toolCount = chat.Tools.Register(mcp, overwrite: false); Console.WriteLine($"Imported {toolCount} tools from MCP server"); Acceso instantáneo aos catálogos de ferramentas curadas. e sobre JSON-RPC; LM-Kit valida esquemas localmente. Why use MCP? tools/list tools/call que . Documentación Mcpclient Modos de execución que coinciden co teu fluxo de traballo Escolla a política correcta para cada xiro de conversación: Funcións sinxelas Unha ferramenta, unha resposta chat.ToolPolicy.MaxCallsPerTurn = 1; chat.ToolPolicy.Choice = ToolChoice.Required; // force at least one call "Como é o tempo en Tokio?" chama Unha vez e respostas. Example: get_weather Funcións múltiples Ferramentas de cadea secuencialmente. chat.ToolPolicy.MaxCallsPerTurn = 5; chat.ToolPolicy.Choice = ToolChoice.Auto; "Converte 75 ° F en Celsius, entón dígame se preciso unha chaqueta." Example: Chama a conversión_temperatura(75, "F", "C") e obtén 23.9°C Chamado get_weather ("corrente_location") e obtén condicións Síntese a resposta: "É 24 ° C e soleado. Unha chaqueta lixeira debe estar ben." Parallel Function Executar varias ferramentas simultaneamente. chat.ToolPolicy.AllowParallelCalls = true; chat.ToolPolicy.MaxCallsPerTurn = 10; "Comparar o tempo en París, Londres e Berlín." Example: Chamados get_weather("Paris"), get_weather("Londres"), get_weather("Berlín") ao mesmo tempo Agardando por todos os resultados, comparacións e respostas Só habilite se as súas ferramentas son idempotentes e seguras. Funcións múltiples paralelas Combina cadea e paralelismo. "Comprobe o tempo en 3 cidades, converta todos os tempos en Fahrenheit e recomende que visitar." Example: Paralelo: capta o tempo para 3 cidades Paralelo: converte todas as temperaturas Sequencial: recomendacións baseadas nos resultados que Todas as opcións, incluíndo e Os estándares son conservadores: paralelo, chamadas máximas limitadas. Documentación política de ToolCall ToolChoice.Specific ForcedToolName Seguridade, control e observación Políticas de control Configurar os estándares seguros e os límites por volta. . ToolCallPolicy documentation chat.ToolPolicy = new ToolCallPolicy { Choice = ToolChoice.Auto, // let model decide MaxCallsPerTurn = 3, // prevent runaway loops AllowParallelCalls = false, // safe default: sequential only // Optional: force a specific tool first // Choice = ToolChoice.Specific, // ForcedToolName = "authenticate_user" }; O ser humano no camiño Revisar, aprobar ou bloquear a execución de ferramentas. , , , . Antes da invocación Despois da convocatoria AnteriorXogadores Recoñecemento // Approve tool calls before execution chat.BeforeToolInvocation += (sender, e) => { Console.WriteLine($"About to call: {e.ToolCall.Name}"); Console.WriteLine($" Arguments: {e.ToolCall.ArgumentsJson}"); // Block sensitive operations if (e.ToolCall.Name == "delete_user" && !UserHasApproved()) { e.Cancel = true; Console.WriteLine(" Blocked by policy"); } }; // Audit results after execution chat.AfterToolInvocation += (sender, e) => { var result = e.ToolCallResult; Console.WriteLine($"{result.ToolName} completed"); Console.WriteLine($" Status: {result.Type}"); Console.WriteLine($" Result: {result.ResultJson}"); _telemetry.LogToolCall(result); // send to monitoring }; // Override token sampling in real time chat.BeforeTokenSampling += (sender, e) => { if (_needsDeterministicOutput) e.Sampling.Temperature = 0.1f; }; // Control memory injection chat.MemoryRecall += (sender, e) => { Console.WriteLine($"Injecting memory: {e.Text.Substring(0, 50)}..."); // e.Cancel = true; // optionally cancel }; Structured Data Flow Every call flows through a typed pipeline for reproducibility and clear logs. Incoming: ToolCall con Id estable e ArgumentsJson. Outgoing: ToolCallResult con ToolCallId, ToolName, ResultJson e Tipo (Éxito ou Erro). Probe-o: mostra de chat de varias voltas Creación de chatbots multi-turn con ferramentas en aplicacións .NET Manifestacións Axente de chamada de ferramentas: durante unha conversación, o modelo pode decidir chamar unha ou varias ferramentas para recoller datos ou executar cálculos, pasar argumentos JSON que coincidan cos de cada ferramenta. , and use each tool's JSON result to produce a grounded reply while preserving full multi-turn context. Tools implement e son xestionados por un rexistro; o comportamento por turno está formado a través . Purpose: Páxina web LM-Kit.NET InputSchema ITool ToolChoice Why tools in chatbots? Respostas fiables e baseadas na fonte (tempo, FX, conversións, APIs empresariais). Cadeaxe axente: chama varias ferramentas nunha vez e combina os resultados. Determinismo e seguridade: esquemas tipados, modos de fracaso claros, control de políticas. Extensibilidade: implementar ITool para a lóxica do dominio; manter o código audible. Eficiencia: descarga de matemáticas / perspectiva para ferramentas; manter o modelo centrado no razoamento. Equipos de produto e plataforma; DevOps e ferramentas internas; aplicacións B2B; educadores e demostracións. Target audience: Respostas accionables, conversións / citas deterministas, memoria multi-turn, extensibilidade fácil. Problem solved: Sample app: Lets you choose a local model (or a custom URI) Rexistra tres ferramentas (moeda, clima, conversión de unidade) Executa un chat multi-turn onde o modelo decide cando chamar ferramentas Estatísticas de xeración de impresións (tokens, razón de parada, velocidade, uso de contexto) Key features: Ferramentas de chamada a través de argumentos JSON Full dialogue memory Páxinas que ligan con "download/load bars" Comandos especiais: /reset, /continuar, /rexerar Múltiples chamadas de ferramentas por turno (e a través de turnos) Ferramentas construídas Tool name Purpose Online? Notes convert_currency ECB rates via Frankfurter (latest or historical) plus optional trend Yes No API key; business days; rounding and date support get_weather Open-Meteo current weather plus optional short hourly forecast Yes No API key; geocoding plus metric/us/si convert_units Offline conversions (length, mass, temperature, speed, etc.) No Temperature is non-linear; can list supported units convert_currency As taxas do BCE a través de Frankfurt (última ou histórica) máis tendencia opcional Si que Sen clave de API; días de traballo; soporte de arredondamento e data get_weather Open-Meteo meteoroloxía actual máis previsión horaria opcional Si que Non hai clave API; xeocodificación máis métrica/us/si convert_units Conversións fóra de liña (longitude, masa, temperatura, velocidade, etc.) non A temperatura é non lineal; pode listar unidades soportadas Implementación de ferramentas : de , , (Esquema de JSON) e Volver a JSON. ITool Name Description InputSchema InvokeAsync(string json) Extend with your own tool: chat.Tools.Register(new MyCustomTool()); // implements ITool Uso único, estable, baixo os nomes. snake_case Modelos soportados (Pick por hardware) Mistral Nemo 2407 12.2B (ao redor de 7.7 GB VRAM) Meta Llama 3.1 8B (ao redor de 6 GB VRAM) Google Gemma 3 4B Medium (aproximadamente 4 GB de VRAM) Microsoft Phi-4 Mini 3.82B (ao redor de 3,3 GB de VRAM) Alibaba Qwen-3 8B (around 5.6 GB VRAM) Microsoft Phi-4 14.7B (ao redor de 11 GB VRAM) IBM Granite 4 7B (ao redor de 6 GB VRAM) Open-AI GPT-OSS 20B (around 16 GB VRAM) Ou proporcionar un URI do modelo personalizado (GGUF/LMK) comandos - clear conversation /reset - continue last assistant message /continue /regenerate - nova resposta para a entrada do último usuario Exemplos rápidos "Converter USD 125 a EUR e amosar unha tendencia de 7 días." "O tempo en A Coruña para as próximas 6 horas (métrica)." "Converter 65 mph a km/h." / "Lista de unidades de presión." "Agora 75 °F a °C, entón 2 km a millas." Comportamento e políticas (referencia rápida) Política de selección de ferramentas: Por defecto, a mostra permite que o modelo decida (ToolChoice.Auto). Pode requirir / prohibir / forzar unha ferramenta específica por turno. Múltiples invocacións de ferramentas: soporta varias invocacións de ferramentas por turno; as saídas inxéctanse de volta ao contexto. Esquemas: InputSchema preciso máis descrición concisa mellorar a construción de argumentos. Rede: Moeda e tempo requiren internet; a conversión de unidade está fóra de liña. Erros: Excepcións claras para entradas non válidas (unidades, datas, lugares). para comezar .NET Framework 4.6.2 ou .NET 6.0 Prerequisites: Download: git clone https://github.com/LM-Kit/lm-kit-net-samples.git cd lm-kit-net-samples/console_net/multi_turn_chat_with_tools Run: dotnet build dotnet run A continuación, elixe un modelo ou pega un URI personalizado. Chatea naturalmente; o asistente chamará unha ou varias ferramentas segundo sexa necesario. , , anytime. /reset /continue /regenerate Project link: Repositorio de GitHub Exemplo completo: Todos os tres camiños de integración // Load a capable local model var model = LM.LoadFromModelID("gptoss:20b"); using var chat = new MultiTurnConversation(model); // 1) ITool implementation chat.Tools.Register(new WeatherTool()); // 2) LMFunctionAttribute methods var tools = LMFunctionToolBinder.FromType (); chat.Tools.Register(tools); // 3) MCP import var mcp = new McpClient(new Uri("https://mcp.example/api"), new HttpClient()); chat.Tools.Register(mcp); // Safety and behavior chat.ToolPolicy = new ToolCallPolicy { Choice = ToolChoice.Auto, MaxCallsPerTurn = 3, // AllowParallelCalls = true // enable only if tools are idempotent }; // Human-in-the-loop chat.BeforeToolInvocation += (_, e) => { /* approve or cancel */ }; chat.AfterToolInvocation += (_, e) => { /* log results */ }; // Run var answer = chat.Submit( "Find 3 relevant docs for 'safety policy' and summarize."); Console.WriteLine(answer.Content); Por que ir local con LM-Kit? Páxina oficial: Cloud Agent Frameworks Custo de API cero: Non hai taxas por token. Executa conversas ilimitadas. Privacidade completa: Os datos do usuario nunca deixan o dispositivo. GDPR / HIPAA amigable. Latencia sub-100ms: a inferencia local elimina completamente as rondas de rede. Funciona offline: os axentes funcionan sen conexión a Internet. Non hai límites de taxa: Escale a millóns de solicitudes sen pasar por alto. Control completo: Propiedade da pila. Sen bloqueo do vendedor ou depreciacións de API. Enxeñaría Próxima Básica Esquemas seguros de tipo: A validación de esquemas de JSON captura argumentos malos antes da execución. Resultados deterministas: Estados de éxito / erro claros, non fragilizantes de análise de rexex. Execución paralela: Execute varias ferramentas simultaneamente cando está seguro. Structured events at every stage, not log archaeology. Full observability: Contratos probables: ferramentas de mock, resultados de inxección, conversas de reprodución. Límites de erro: fracasos graciosos con lóxica de retraso e fallos. Xestión de funcións manuais O modelo decide: o axente elixe de forma autónoma ferramentas e argumentos, sen cadeas fráxiles se/else. Auto-cadea: varias chamadas de ferramentas por quenda, os resultados son devoltos automaticamente. Register tools once, not per-model or per-prompt. 90% less boilerplate: Seguridade incorporada: Prevención de loop, límites de chamadas máximas, ganchos de aprobación fóra da caixa. API de modelo agnóstico: O mesmo código funciona en Mistral, LLaMA, Qwen, Granite, GPT-OSS. Mellora progresiva: engade ferramentas sen refactorizar a lóxica da conversación. Performance and Limitations Expectativas de rendemento Invocación de ferramentas sobre a cabeza: Arredor de 2 a 5 ms por chamada (parsing máis validación) Ferramentas de rede: 50 a 500 ms dependendo da API Ferramentas locais: Menos de 1 ms A inferencia do modelo segue sendo o factor de latencia primario. Requisitos Models must support tool calling (check ). HasToolCalls As ferramentas dependentes da rede requiren unha conexión a Internet. A execución paralela require ferramentas seguras e idempotentes. Memoria GPU recomendada: 6 a 16 GB de VRAM dependendo do tamaño do modelo. Limitacións coñecidas A calidade da selección de ferramentas depende de descricións e esquemas claros. Os obxectos complexos enmarcados en argumentos poden confundir modelos máis pequenos. As cadeas de ferramentas moi longas (máis de 10 chamadas) poden exceder as fiestras de contexto. Listo para construír? Clone the sample git clone https://github.com/LM-Kit/lm-kit-net-samples.git cd lm-kit-net-samples/console_net/multi_turn_chat_with_tools Pick your integration approach Need full control? Use ITool Prototyping quickly? Use [LMFunction] Using external catalogs? Use McpClient Replace demo tools with your APIs, databases, or business logic. Add your domain logic Set policies that fit your use case Simple lookups: MaxCallsPerTurn = 1 Complex workflows: with approval hooks MaxCallsPerTurn = 10 On-device. Private. Reliable. Observable. Ship agents that actually work Comezar a construír fluxos de traballo de axentes que respecten a privacidade do usuario, executar en calquera lugar e permanecer baixo o seu control.