LMKit Agents Tools BuiltIn

https://docs.lm-kit.com/lm-kit-net
Admin
This project provides documentation for the built-in agent tools within the LMKit framework.
Tokens:2,671,407
Snippets:26,579
Trust Score:8.1
Update:4 months ago
Show doc for...
Tokens:
Raw
### Implement Few-Shot CoT with Example Reasoning

Source: https://docs.lm-kit.com/lm-kit-net/guides/glossary/ai-agent-reasoning.html

Provide a system prompt with a detailed example of a question and its step-by-step answer. This guides the agent to follow a similar reasoning format for new problems.

```csharp
var agent = Agent.CreateBuilder(model)
    .WithSystemPrompt("""
        Solve problems by showing your reasoning step by step.

        Example:
        Q: A store has 50 apples. They sell 30% and receive a shipment of 25 more. How many do they have?
        A: Let me work through this:
           - Starting amount: 50 apples
           - Sold 30%: 50 × 0.30 = 15 apples sold
           - Remaining: 50 - 15 = 35 apples
           - New shipment: 35 + 25 = 60 apples
           - Final answer: 60 apples

        Now solve the following problem using the same approach.
        """)
    .Build();

```

--------------------------------

### FileSystemWatchStart

Source: https://docs.lm-kit.com/lm-kit-net/api/LMKit.Agents.Tools.BuiltIn.BuiltInTools.html

Gets a new FileSystem Watch Start tool instance.

```APIDOC
## FileSystemWatchStart

### Description
Gets a new FileSystem Watch Start tool instance.

### Method
GET

### Endpoint
/tools/filesystemwatchstart
```

--------------------------------

### Complete LM-Kit Agent Memory Example

Source: https://docs.lm-kit.com/lm-kit-net/guides/how-to/enable-automatic-memory-extraction.html

This example demonstrates the complete setup for an LM-Kit agent, including loading models, creating or restoring memory, enabling LLM-based automatic extraction, and running a chat loop. It shows how memory persists across sessions.

```csharp
using System.Text;
using LMKit.Model;
using LMKit.Agents;
using LMKit.Agents.Memory;
using LMKit.TextGeneration;
using LMKit.TextGeneration.Sampling;

LMKit.Licensing.LicenseManager.SetLicenseKey("");

Console.InputEncoding = Encoding.UTF8;
Console.OutputEncoding = Encoding.UTF8;

string memoryPath = "conversation_memory.bin";

// Load models
using LM embeddingModel = LM.LoadFromModelID("embeddinggemma-300m");
using LM chatModel = LM.LoadFromModelID("gemma4:e4b");

// Create or restore memory
AgentMemory memory;
if (File.Exists(memoryPath))
{
    memory = AgentMemory.Deserialize(memoryPath, embeddingModel);
    Console.WriteLine($"Restored {memory.DataSources.Count} memory source(s) from disk.\n");
}
else
{
    memory = new AgentMemory(embeddingModel);
}

// Enable automatic extraction
memory.ExtractionMode = MemoryExtractionMode.LlmBased;
memory.RunExtractionSynchronously = true;

// Build agent
var agent = Agent.CreateBuilder(chatModel)
    .WithMemory(memory)
    .WithPlanning(PlanningStrategy.None)
    .Build();

var executor = new AgentExecutor();

// Chat loop
while (true)
{
    Console.Write("You: ");
    string? input = Console.ReadLine();

    if (string.IsNullOrWhiteSpace(input))
        continue;

    if (input.Equals("quit", StringComparison.OrdinalIgnoreCase))
    {
        memory.Serialize(memoryPath);
        Console.WriteLine("Memory saved. Goodbye!");
        break;
    }

    var result = executor.Execute(agent, input);
    Console.WriteLine($"Assistant: {result.Content}\n");
}
```

--------------------------------

### Run Named Entity Recognition Demo

Source: https://docs.lm-kit.com/lm-kit-net/guides/samples-overview/named-entity-recognition-demo.html

Clone the repository and run the .NET application to start the interactive demo. Ensure you have .NET 8.0 or later installed.

```bash
git clone https://github.com/LM-Kit/lm-kit-net-samples
cd lm-kit-net-samples/console_net/text-analysis/named-entity-recognition/ner_entity_extractor
dotnet run
```

--------------------------------

### Start Property

Source: https://docs.lm-kit.com/lm-kit-net/api/LMKit.Speech.AudioSegment.Start.html

Gets the start time of the segment within the audio stream. This property returns a TimeSpan value representing the start time.

```APIDOC
## Start Property

### Description
Gets the start time of the segment within the audio stream.

### Property Value
TimeSpan - The start time of the segment.
```

--------------------------------

### Create and Configure Agent Step-by-Step

Source: https://docs.lm-kit.com/lm-kit-net/api/LMKit.Agents.Agent.-ctor.html

Demonstrates creating an agent using the default constructor and then configuring its model, identity, and planning strategy.

```csharp
using LMKit.Model;
using LMKit.Agents;
var agent = new Agent();
using var model = LM.LoadFromModelID("qwen3:8b");
agent.Model = model;
agent.Identity = new AgentIdentity("Helper", "Assist with tasks.");
agent.Planning = PlanningStrategy.ChainOfThought;
var result = agent.Run("What is 15% of 200?");
Console.WriteLine(result.Content);__C#__
```

--------------------------------

### AudioSegment Start Property

Source: https://docs.lm-kit.com/lm-kit-net/api/LMKit.Speech.AudioSegment.Start.html

Gets the start time of the segment within the audio stream. This property is read-only.

```C#
[JsonPropertyName("Start")]
public TimeSpan Start { get; }
```

--------------------------------

### Initialize and Use BM25 Retrieval Strategy

Source: https://docs.lm-kit.com/lm-kit-net/api/LMKit.Retrieval.Bm25.Bm25RetrievalStrategy.html

Demonstrates how to initialize the RagEngine with the Bm25RetrievalStrategy, configure its parameters (K1, B, Language), import text, and perform a keyword query.

```csharp
using LMKit.Model;
using LMKit.Retrieval;
using LMKit.Retrieval.Bm25;

LM embeddingModel = LM.LoadFromModelID("embeddinggemma-300m");
RagEngine ragEngine = new RagEngine(embeddingModel);

// Use pure BM25 keyword retrieval.
ragEngine.RetrievalStrategy = new Bm25RetrievalStrategy
{
    K1 = 1.5f,
    B = 0.6f,
    Language = Language.English
};

ragEngine.ImportText("The quick brown fox jumps over the lazy dog.", "docs", "animals");
var results = await ragEngine.QueryAsync("brown fox");
```

--------------------------------

### SpeechToText Start Property Declaration

Source: https://docs.lm-kit.com/lm-kit-net/api/LMKit.Speech.SpeechToText.Start.html

This C# code shows the declaration of the Start property, which is of type TimeSpan and is used to get or set the transcription start time.

```csharp
public TimeSpan Start { get; set; }
```

--------------------------------

### Get Pen Color

Source: https://docs.lm-kit.com/lm-kit-net/api/LMKit.Graphics.Drawing.Pen.Color.html

Retrieves the color of the pen. This example shows how to get the green component of the pen's color.

```C#
var pen = new Pen(new Color32(0, 255, 0), 2);
byte green = pen.Color.G; // 255
```

--------------------------------

### Create a new .NET Console Project

Source: https://docs.lm-kit.com/lm-kit-net/guides/how-to/summarize-documents-and-text.html

This command creates a new .NET console application named SummarizeQuickstart and navigates into its directory. It then adds the LM-Kit.NET package to the project.

```shell
dotnet new console -n SummarizeQuickstart
cd SummarizeQuickstart
dotnet add package LM-Kit.NET
```

--------------------------------

### GuidGenerate

Source: https://docs.lm-kit.com/lm-kit-net/api/LMKit.Agents.Tools.BuiltIn.BuiltInTools.GuidGenerate.html

Gets a new GUID generate tool instance. This property provides access to a tool that can generate new GUIDs.

```APIDOC
## GuidGenerate

### Description
Gets a new GUID generate tool instance.

### Property Value

GuidGenerateTool
```

--------------------------------

### Build and Run the Tool Calling Assistant Demo

Source: https://docs.lm-kit.com/lm-kit-net/guides/samples-overview/tool-calling-assistant-demo.html

Instructions for building and running the console application demo. Ensure you have .NET 8.0 or later installed and sufficient VRAM for your selected model.

```shell
cd demos/console_net/ai-agents/tools-and-function-calling/tool_calling_assistant
dotnet build
dotnet run
```

--------------------------------

### Color32 Initialization Examples

Source: https://docs.lm-kit.com/lm-kit-net/api/LMKit.Graphics.Primitives.Color32.html

Demonstrates creating Color32 instances for opaque white, semi-transparent red, and packing/unpacking RGBA values.

```csharp
// Opaque white
var white = new Color32(255, 255, 255);

// Semi-transparent red
var red50 = new Color32(255, 0, 0, 128);

// Pack/unpack RRGGBBAA
int rgba = red50.ToRgba();          // 0xFF000080
var again = Color32.FromRgba(rgba); // equal to red50
```

--------------------------------

### Setting the Transcription Start Time

Source: https://docs.lm-kit.com/lm-kit-net/api/LMKit.Speech.SpeechToText.Start.html

This C# example demonstrates how to set the Start property of a SpeechToText engine to begin transcription at a specific time offset, in this case, 30 seconds from the start of the audio.

```csharp
engine.Start = TimeSpan.FromSeconds(30);
```

--------------------------------

### Start Property

Source: https://docs.lm-kit.com/lm-kit-net/api/LMKit.Speech.SpeechToText.Start.html

Gets or sets the time offset at which transcription should begin. This property accepts a TimeSpan value to specify the starting point for speech-to-text processing.

```APIDOC
## Start Property

### Description
Gets or sets the time offset at which transcription should begin.

### Property Type
TimeSpan

### Value
A TimeSpan indicating the point, measured from the start of the audio content, where speech-to-text processing will commence.

### Example
```csharp
engine.Start = TimeSpan.FromSeconds(30);
```
```

--------------------------------

### Quick Agent Creation and Configuration

Source: https://docs.lm-kit.com/lm-kit-net/api/LMKit.Agents.Templates.AgentTemplates.html

Demonstrates quick creation of chat and code agents using predefined models. Also shows how to get a template first, configure it with specific parameters like model, content type, and tone, and then build the agent.

```C#
var chatAgent = AgentTemplates.Chat(model).Build();
var codeAgent = AgentTemplates.Code(model).WithLanguages("C#").Build();

// Or get template first, then configure
var template = AgentTemplates.Writer()
    .WithModel(model)
    .WithContentType(ContentType.BlogPost)
    .WithTone(WritingTone.Conversational);
var agent = template.Build();
```

--------------------------------

### MessageSegment.Start

Source: https://docs.lm-kit.com/lm-kit-net/api/LMKit.TextGeneration.Chat.ChatHistory.Message.MessageSegment.Start.html

Gets the start offset (inclusive) within Content for this segment.

```APIDOC
## MessageSegment.Start

### Description
Gets the start offset (inclusive) within Content for this segment.

### Property Value
int
```

--------------------------------

### Registering Multiple DataSources with RagEngine

Source: https://docs.lm-kit.com/lm-kit-net/api/LMKit.Retrieval.RagEngine.AddDataSources.html

Example demonstrating how to initialize a RagEngine and add multiple DataSource objects.

```csharp
LM embeddingModel = LM.LoadFromModelID("embeddinggemma-300m");
RagEngine ragEngine = new RagEngine(embeddingModel);

var sources = new List<DataSource>
{
    new DataSource("source1"),
    new DataSource("source2")
};

ragEngine.AddDataSources(sources);

Console.WriteLine("Multiple DataSources added successfully.");
```

--------------------------------

### Complete Example: Customer Profile Agent

Source: https://docs.lm-kit.com/lm-kit-net/guides/glossary/ai-agent-memory.html

Demonstrates initializing memory, populating it with customer facts, and creating an agent that automatically recalls relevant information. This example integrates all previous concepts into a cohesive agent.

```csharp
// Initialize memory
var memory = await MemoryBuilder.Generate(
    modelPath: "nomic-embed-text",
    memoryPath: "customer_memory.bin"
);

// Populate with customer facts
await memory.SaveInformationAsync(
    dataSourceIdentifier: "acmeProfile",
    text: "Ideal customer size: 200-500 employees",
    sectionIdentifier: "size"
);

await memory.SaveInformationAsync(
    dataSourceIdentifier: "acmeProfile",
    text: "Target revenue: $20M-$200M annually",
    sectionIdentifier: "revenue"
);

await memory.SaveInformationAsync(
    dataSourceIdentifier: "acmeProfile",
    text: "Primary industries: Software, IT services, digital media",
    sectionIdentifier: "industries"
);

// Create agent with memory
var model = LM.LoadFromModelID("qwen:2.5-instruct-0.5b");
using var agent = new MultiTurnConversation(model)
{
    Memory = memory,
    SystemPrompt = "Provide information about our ideal customer profile."
};

// Agent recalls relevant facts automatically
var answer = agent.Submit("What industries do our customers work in?");
// Response: "Our customers primarily work in software, IT services, 
// and digital media industries."
```

--------------------------------

### Connect to MCP Server and Discover Tools

Source: https://docs.lm-kit.com/lm-kit-net/api/LMKit.Mcp.Client.McpClient.html

Demonstrates how to create an McpClient instance, set authentication, initialize the connection, and retrieve available tools from an MCP server. Ensure the server URL is correct and an API key is provided if required.

```csharp
using LMKit.Mcp.Client;
using LMKit.Mcp.Tools;
using System;
using System.Threading.Tasks;
// Create MCP client pointing to a server
using var mcpClient = new McpClient("https://mcp.example.com/api");
// Optional: Set authentication
mcpClient.SetBearerToken("your-api-key");
// Initialize connection
await mcpClient.InitializeAsync();
Console.WriteLine($"Session ID: {mcpClient.SessionId}");
Console.WriteLine($"Protocol: {mcpClient.McpProtocolVersion}");
// Discover available tools
var tools = await mcpClient.GetToolsAsync();
Console.WriteLine($"Available tools: {tools.Count}");
foreach (var tool in tools)
{
Console.WriteLine($"- {tool.Name}: {tool.Description}");
}
```

--------------------------------

### StartIndex Property

Source: https://docs.lm-kit.com/lm-kit-net/api/LMKit.Speech.Dictation.CommandMatch.StartIndex.html

Gets the zero-based starting index of the match in the source text.

```APIDOC
## StartIndex Property

### Description
Gets the zero-based starting index of the match in the source text.

### Property Value

int
```

--------------------------------

### Instantiate and Get ElementType

Source: https://docs.lm-kit.com/lm-kit-net/api/LMKit.Extraction.TextExtractionElement.ElementType.html

Example of creating a TextExtractionElement and then accessing its ElementType property.

```csharp
var el = new TextExtractionElement("Amount", ElementType.Double);
Console.WriteLine(el.ElementType); // Decimal
```

--------------------------------

### Registering All Tools with a Predefined Profile

Source: https://docs.lm-kit.com/lm-kit-net/api/LMKit.Agents.Tools.BuiltIn.BuiltInToolsExtensions.html

This example demonstrates how to register all available built-in tools by using the predefined 'All' profile.

```csharp
var registry = new ToolRegistry();
registry.AddBuiltIns(BuiltInProfiles.All);
```

--------------------------------

### DocumentSegment.StartPage

Source: https://docs.lm-kit.com/lm-kit-net/api/LMKit.Extraction.DocumentSegment.StartPage.html

Gets the 1-based page number where this document segment starts (inclusive).

```APIDOC
## Property StartPage

### Description
Gets the 1-based page number where this document segment starts (inclusive).

### Property Value
`int` - A positive integer representing the first page of the segment.

### Example
```csharp
DocumentSegment segment = result.Segments[0];
Console.WriteLine($"First document starts at page {segment.StartPage}");
```
```

--------------------------------

### Run Multi-Format to Markdown Demo

Source: https://docs.lm-kit.com/lm-kit-net/guides/samples-overview/document-conversion-demo.html

Clone the repository, navigate to the demo directory, and run the .NET application to start the interactive conversion process.

```shell
git clone https://github.com/LM-Kit/lm-kit-net-samples
cd lm-kit-net-samples/console_net/document-intelligence/document-conversion/multi_format_to_markdown
dotnet run
```

--------------------------------

### Install Node.js MCP Servers with npx

Source: https://docs.lm-kit.com/lm-kit-net/guides/samples-overview/mcp-stdio-integration-demo.html

No installation is needed for Node.js MCP servers as npx downloads them on first use. This command shows how to get help for the filesystem server.

```shell
# No installation needed - npx downloads on first use
npx @modelcontextprotocol/server-filesystem --help
```

--------------------------------

### Create and Configure .NET Project

Source: https://docs.lm-kit.com/lm-kit-net/guides/how-to/build-voice-commanded-agent.html

Initializes a new console application, navigates to the project directory, and adds the LM-Kit.NET package.

```shell
dotnet new console -n VoiceAgent
cd VoiceAgent
dotnet add package LM-Kit.NET
```

--------------------------------

### Integrating Vector Stores with RagEngine

Source: https://docs.lm-kit.com/lm-kit-net/guides/faq/vector-database-options.html

Demonstrates how to initialize RagEngine and plug in different vector store implementations, including the default FileSystemVectorStore, Qdrant, and PostgreSQL (pgvector).

```csharp
using LMKit.Retrieval;

var ragEngine = new RagEngine(embeddingModel);

// Default: uses FileSystemVectorStore internally
ragEngine.ImportDocument("manual.pdf");

// Or wire up Qdrant for production
ragEngine.VectorStore = new QdrantEmbeddingStore("http://localhost:6334");
ragEngine.ImportDocument("manual.pdf");

// Or use PostgreSQL (pgvector) for production
ragEngine.VectorStore = new PgVectorEmbeddingStore(
    "Host=localhost;Port=5432;Database=vector_test;Username=postgres;Password=postgres");
ragEngine.ImportDocument("manual.pdf");
```

--------------------------------

### Create an Agent with ReAct Planning Strategy

Source: https://docs.lm-kit.com/lm-kit-net/api/LMKit.Agents.Planning.ReActHandler.html

Demonstrates how to initialize an LM model, register tools, and build an agent using the ReAct planning strategy. This setup allows the agent to use a Thought-Observation loop for reasoning and tool invocation.

```csharp
using LMKit.Model;
using LMKit.Agents;
using LMKit.Agents.Tools;
using System;
using System.Threading.Tasks;
// Define tools for the agent
public class SearchTools
{
[LMFunction("search_web", "Search the web for information")]
public string SearchWeb(string query)
{
return $"Search results for: {query}";
}
[LMFunction("calculate", "Perform a calculation")]
public double Calculate(string expression)
{
    // Simple calculation logic
    return 42.0;
}

}
LM model = LM.LoadFromModelID("llama-3.2-3b");
// Register tools
var tools = new ToolRegistry();
tools.Register(new SearchTools());
// Build agent with ReAct planning strategy
Agent agent = new AgentBuilder()
.WithModel(model)
.WithPersona("Research Assistant")
.WithInstruction("Use available tools to answer questions. Think step by step.")
.WithPlanning(PlanningStrategy.ReAct)
.WithTools(tools)
.Build();
// Execute - the agent will use Thought/Observation loop with native tool calls
using var executor = new AgentExecutor();
var result = await executor.ExecuteAsync(agent, "What is the population of France?");
Console.WriteLine($"Final Answer: {result.Content}");
Console.WriteLine($"Reasoning: {result.ReasoningTrace}");
```

--------------------------------

### StartIndex Property

Source: https://docs.lm-kit.com/lm-kit-net/api/LMKit.Speech.Dictation.CommandMatch.StartIndex.html

Gets the zero-based starting index of the match in the source text. This is a read-only property.

```csharp
public readonly int StartIndex { get; }
```

--------------------------------

### Run the MCP Stdio Integration Demo

Source: https://docs.lm-kit.com/lm-kit-net/guides/samples-overview/mcp-stdio-integration-demo.html

Navigate to the demo directory, build the .NET console application, and then run it to start the MCP stdio integration demo.

```shell
cd demos/console_net/ai-agents/mcp/mcp_stdio_integration
dotnet build
dotnet run
```

--------------------------------

### Result Property C# Example

Source: https://docs.lm-kit.com/lm-kit-net/api/LMKit.Agents.Streaming.ToolCallInfo.Result.html

Gets the tool result, if available. This is a read-only string property.

```csharp
public string Result { get; }
```

--------------------------------

### Check SkillWatcher IsRunning Status

Source: https://docs.lm-kit.com/lm-kit-net/api/LMKit.Agents.Skills.SkillWatcher.IsRunning.html

Demonstrates how to check the IsRunning property of a SkillWatcher instance. The property returns a boolean indicating if the watcher is currently monitoring. This example shows the status before starting and after starting the watcher.

```csharp
var watcher = new SkillWatcher(registry, "./skills");
Console.WriteLine(watcher.IsRunning); // False
watcher.Start();
Console.WriteLine(watcher.IsRunning); // True
```

--------------------------------

### Plan-and-Execute Example

Source: https://docs.lm-kit.com/lm-kit-net/guides/glossary/ai-agent-planning.html

Outlines generating a complete plan upfront before execution. This offers predictable flow and allows for plan review.

```text
Planning Phase:
- Step 1: Fetch customer data from database
- Step 2: Calculate quarterly metrics
- Step 3: Generate trend visualization
- Step 4: Create executive summary

Execution Phase:
[Execute each step with progress monitoring]
[Detect failures and trigger replanning if needed]
____
```

--------------------------------

### Create a New .NET Console Project

Source: https://docs.lm-kit.com/lm-kit-net/guides/how-to/build-content-moderation-filter.html

Initialize a new .NET console application for the moderation quickstart. This command creates the project directory and basic file structure.

```bash
dotnet new console -n ModerationQuickstart
cd ModerationQuickstart
dotnet add package LM-Kit.NET
```

--------------------------------

### UriTemplate Property Example

Source: https://docs.lm-kit.com/lm-kit-net/api/LMKit.Mcp.Abstractions.McpResourceTemplate.UriTemplate.html

Gets or sets the URI template pattern (RFC 6570 format). Example: "file:///{path}" or "db:///{schema}/{table}".

```csharp
public string UriTemplate { get; set; }
```

--------------------------------

### Description Property

Source: https://docs.lm-kit.com/lm-kit-net/api/LMKit.Agents.Tools.LMFunctionAttribute.Description.html

Gets the description of what this tool does. This description is used to guide the model in selecting the appropriate tool.

```APIDOC
## Description Property

### Description
Gets the description of what this tool does. This description is used to guide the model in selecting the appropriate tool.

### Property Value
string

A concise, human-readable summary displayed to the model to guide tool selection.

### Remarks
This description directly influences when the model decides to use the tool. Write it as if explaining the tool's purpose to the model.
**Description Best Practices:**
  * Use imperative mood ("Get the weather" not "Gets the weather")
  * Keep under 200 characters
  * Be specific about what the tool does
  * Mention input/output if helpful
```

--------------------------------

### Example: Importing a Document into RagEngine

Source: https://docs.lm-kit.com/lm-kit-net/api/LMKit.Retrieval.RagEngine.Import.html

Demonstrates how to initialize an embedding model and RagEngine, create an Attachment, and then import the attachment into a specified data source and section.

```csharp
LM embeddingModel = LM.LoadFromModelID("embeddinggemma-300m");
RagEngine ragEngine = new RagEngine(embeddingModel);

var attachment = new Attachment("document.pdf");

DataSource dataSource = ragEngine.Import(
    attachment: attachment,
    dataSourceIdentifier: "documents",
    sectionIdentifier: "manual_v1");
```

--------------------------------

### Initialize Web Search Tools

Source: https://docs.lm-kit.com/lm-kit-net/guides/samples-overview/research-assistant-demo.html

Demonstrates how to create instances of the WebSearchTool for different providers, including those requiring API keys and custom configurations.

```csharp
// Default: DuckDuckGo (no API key required)
var webSearch = BuiltInTools.WebSearch;

// Brave Search (requires API key)
var braveSearch = BuiltInTools.CreateWebSearch(WebSearchProvider.Brave, "your-brave-api-key");

// Tavily (AI-optimized, requires API key)
var tavilySearch = BuiltInTools.CreateWebSearch(WebSearchProvider.Tavily, Environment.GetEnvironmentVariable("TAVILY_API_KEY"));

// Serper (Google results, requires API key)
var serperSearch = BuiltInTools.CreateWebSearch(WebSearchProvider.Serper, "your-serper-api-key");

// Self-hosted SearXNG
var searxSearch = BuiltInTools.CreateWebSearch(new WebSearchToolOptions
{
    Provider = WebSearchProvider.SearXNG,
    BaseUrl = "https://your-searxng-instance.com"
});
```

--------------------------------

### AllowUserInfo Property C# Example

Source: https://docs.lm-kit.com/lm-kit-net/api/LMKit.Agents.Tools.BuiltIn.IO.EnvironmentToolOptions.AllowUserInfo.html

Gets or sets whether user name is exposed. Default is false.

```csharp
public bool AllowUserInfo { get; set; }
```

--------------------------------

### GuidParse

Source: https://docs.lm-kit.com/lm-kit-net/api/LMKit.Agents.Tools.BuiltIn.BuiltInTools.GuidParse.html

Gets a new GUID parse tool instance. This is a static property that returns an instance of the GuidParseTool.

```APIDOC
## GuidParse

### Description
Gets a new GUID parse tool instance.

### Property Value
GuidParseTool
```

--------------------------------

### Run the Model Catalog Demo Application

Source: https://docs.lm-kit.com/lm-kit-net/guides/samples-overview/model-catalog-demo.html

Instructions to clone the repository, navigate to the demo directory, and run the console application. This will initiate the model catalog browser.

```shell
git clone https://github.com/LM-Kit/lm-kit-net-samples.git
cd lm-kit-net-samples/console_net/local-inference/model-catalog/host_aware_model_picker
dotnet run
```

--------------------------------

### Instantiate and Run TutorAgentTemplate

Source: https://docs.lm-kit.com/lm-kit-net/api/LMKit.Agents.Templates.TutorAgentTemplate.html

Demonstrates how to create an instance of TutorAgentTemplate, configure it with specific tutoring parameters, and then run a tutoring session with a given prompt. Ensure the 'model' variable is defined and accessible.

```csharp
var agent = new TutorAgentTemplate()
    .WithModel(model)
    .WithSubject("mathematics")
    .WithLevel(TutorLevel.Intermediate)
    .WithStyle(TutorStyle.Socratic)
    .Build();

var result = await agent.RunAsync("Explain how derivatives work in calculus");
```

--------------------------------

### Name Property

Source: https://docs.lm-kit.com/lm-kit-net/api/LMKit.Agents.Tools.BuiltIn.BuiltInToolDescriptor.Name.html

Gets the unique name of the tool. This name serves as an identifier, for example, 'filesystem_read' or 'http_get'.

```APIDOC
## Name Property

### Description
Gets the unique name of the tool (for example, `"filesystem_read"` or `"http_get"`).

### Property Value
string
```

--------------------------------

### Example: Create a new C# class file

Source: https://docs.lm-kit.com/lm-kit-net/guides/samples-overview/multi-turn-chat-with-code-writing-assistant-demo.html

Instruct the assistant to create a new C# class file with specified methods in a particular directory.

```Text
You: Create a new C# class called UserService in ./Services/UserService.cs with CRUD methods

```

--------------------------------

### StatusPrefix Property C# Example

Source: https://docs.lm-kit.com/lm-kit-net/api/LMKit.Agents.Streaming.TextWriterStreamHandler.StatusPrefix.html

Gets or sets the prefix for status tokens. This property is of type string.

```csharp
public string StatusPrefix { get; set; }
```

--------------------------------

### AgentSpan.StartTime

Source: https://docs.lm-kit.com/lm-kit-net/api/LMKit.Agents.Observability.AgentSpan.StartTime.html

Gets the start time of this span. This property returns a DateTime value representing when the span began.

```APIDOC
## Property StartTime

### Description
Gets the start time of this span.

### Property Value
DateTime - The start time of the span.
```

--------------------------------

### PlanAndExecute Agent Workflow Example

Source: https://docs.lm-kit.com/lm-kit-net/guides/faq/agent-planning-strategies.html

Demonstrates the two-phase approach of PlanAndExecute, showing the initial plan followed by sequential execution of each step.

```plaintext
Plan:
1. Search for recent sales data
2. Calculate quarterly growth rate
3. Compare with industry benchmarks
4. Summarize findings

Executing step 1... [tool call]
Executing step 2... [calculation]
Executing step 3... [tool call]
Executing step 4... [synthesis]
```

--------------------------------

### Get StartTime of AgentSpan

Source: https://docs.lm-kit.com/lm-kit-net/api/LMKit.Agents.Observability.AgentSpan.StartTime.html

Retrieves the start time of an AgentSpan. This property is read-only and returns a DateTime value.

```csharp
public DateTime StartTime { get; }
```

--------------------------------

### FileSystemWatchStartTool()

Source: https://docs.lm-kit.com/lm-kit-net/api/LMKit.Agents.Tools.BuiltIn.IO.FileSystemWatchStartTool.-ctor.html

Initializes a new instance of the FileSystemWatchStartTool class with default settings.

```APIDOC
## FileSystemWatchStartTool()

### Description
Initializes a new instance of the FileSystemWatchStartTool class with default settings.

### Method
Constructor

### Parameters
None

### Response Example
```csharp
// Example usage:
var watcher = new FileSystemWatchStartTool();
```
```

--------------------------------

### FileSystemWatchStartTool() Constructor

Source: https://docs.lm-kit.com/lm-kit-net/api/LMKit.Agents.Tools.BuiltIn.IO.FileSystemWatchStartTool.-ctor.html

Initializes a new instance of FileSystemWatchStartTool with default settings. No specific setup is required beyond calling the constructor.

```csharp
public FileSystemWatchStartTool()
```

--------------------------------

### Progress Property

Source: https://docs.lm-kit.com/lm-kit-net/api/LMKit.Speech.SpeechToText.OnProgressEventArgs.Progress.html

Gets the current progress of the transcription operation, as an integer percentage between 0 (not started) and 100 (complete).

```APIDOC
## Progress Property

### Description
Gets the current progress of the transcription operation, as an integer percentage between 0 (not started) and 100 (complete).

### Property Value

`int`
```

--------------------------------

### SpokenExample Property

Source: https://docs.lm-kit.com/lm-kit-net/api/LMKit.Speech.Dictation.CommandInfo.SpokenExample.html

Gets a human-readable example of the spoken form of a command. This is useful for displaying a user-friendly representation of the command.

```APIDOC
## SpokenExample Property

### Description
Gets a human-readable example of the spoken form. This property returns a cleaned-up spoken phrase suitable for display to users.

### Property Type
string

### Access
public string { get; }
```

--------------------------------

### Run Sampler Comparison Lab Demo

Source: https://docs.lm-kit.com/lm-kit-net/guides/samples-overview/sampling-controls-demo.html

Clone the repository and run the .NET application to start the interactive sampler comparison lab.

```shell
git clone https://github.com/LM-Kit/lm-kit-net-samples
cd lm-kit-net-samples/console_net/local-inference/sampling-controls/sampler_comparison_lab
dotnet run
```

--------------------------------

### Configure and Submit Prompt with System Instruction

Source: https://docs.lm-kit.com/lm-kit-net/api/LMKit.TextGeneration.IConversation.html

Demonstrates how to load a model, create a conversation, set a system prompt and maximum completion tokens, and submit a user prompt. The result's completion is then printed to the console.

```csharp
using LMKit.Model;
using LMKit.TextGeneration;
LM model = LM.LoadFromModelID("gemma4:e4b");
var conversation = new MultiTurnConversation(model);
conversation.SystemPrompt = "You are a helpful assistant.";
conversation.MaximumCompletionTokens = 256;
var result = conversation.Submit("What is the capital of Japan?");
Console.WriteLine(result.Completion);
```

--------------------------------

### ConnectionTimeout Property

Source: https://docs.lm-kit.com/lm-kit-net/api/LMKit.Mcp.Transport.StdioTransportOptions.ConnectionTimeout.html

Gets or sets the maximum time to wait for the process to start. The default value is 10 seconds.

```APIDOC
## ConnectionTimeout

### Description
Gets or sets the maximum time to wait for the process to start. The default value is 10 seconds.

### Property Value
TimeSpan - The timeout for the process to become responsive.
```

--------------------------------

### ConnectionTimeout Property

Source: https://docs.lm-kit.com/lm-kit-net/api/LMKit.Mcp.Transport.StdioTransportOptions.ConnectionTimeout.html

Gets or sets the maximum time to wait for the process to start. The default value is 10 seconds.

```csharp
public TimeSpan ConnectionTimeout { get; set; }
```

--------------------------------

### Complete Example: Dynamic System Prompt for Chat

Source: https://docs.lm-kit.com/lm-kit-net/guides/how-to/build-dynamic-prompts-with-templates.html

Demonstrates a full example of creating a dynamic system prompt for a chat conversation using templates. This includes setting up the model, conversation parameters, and submitting a query.

```csharp
using System.Text;
using LMKit.Model;
using LMKit.TextGeneration;
using LMKit.TextGeneration.Chat;
using LMKit.TextGeneration.Prompts;
using LMKit.TextGeneration.Sampling;

LMKit.Licensing.LicenseManager.SetLicenseKey("");
Console.InputEncoding = Encoding.UTF8;
Console.OutputEncoding = Encoding.UTF8;

// Define a template for the system prompt
var systemTemplate = PromptTemplate.Parse(@"You are an expert assistant specializing in {{domain}}.
{{#if verbose}}Provide thorough explanations with examples.{{#else}}Keep answers concise.{{/if}}
Always respond in {{language:English}}.");

// Render with runtime configuration
string systemPrompt = systemTemplate.Render(new PromptTemplateContext
{
    ["domain"] = "cloud architecture",
    ["verbose"] = false,
    ["language"] = "English"
});

Console.WriteLine($"System prompt:\n{systemPrompt}\n");

// Use the rendered prompt in a conversation
using LM model = LM.LoadFromModelID("gemma4:e4b",
    loadingProgress: p => { Console.Write($"\rLoading: {p * 100:F0}%"); return true; });
Console.WriteLine();

var chat = new MultiTurnConversation(model)
{
    MaximumCompletionTokens = 1024,
    SamplingMode = new RandomSampling { Temperature = 0.7f },
    SystemPrompt = systemPrompt
};

var result = chat.Submit("What is the CAP theorem?", CancellationToken.None);
Console.WriteLine(result.Content);
```

--------------------------------

### RejectionReason Property C# Example

Source: https://docs.lm-kit.com/lm-kit-net/api/LMKit.Mcp.Client.McpSamplingRequestEventArgs.RejectionReason.html

Gets or sets the rejection reason. This property is relevant when the sampling request is rejected.

```csharp
public string RejectionReason { get; set; }
```

--------------------------------

### LineCap Property

Source: https://docs.lm-kit.com/lm-kit-net/api/LMKit.Graphics.Drawing.Pen.LineCap.html

Gets or sets the style used to cap the start and end points of lines. Defaults to Butt.

```APIDOC
## LineCap Property

### Description
Gets or sets the style used to cap the start and end points of lines. Defaults to Butt.

### Property Value
LineCap

### Example
```csharp
var pen = new Pen(new Color32(0, 0, 0), 2) { LineCap = LineCap.Square };
```
```

--------------------------------

### Create and Run a Simple Agent

Source: https://docs.lm-kit.com/lm-kit-net/api/LMKit.Agents.Agent.html

Demonstrates how to instantiate a basic agent with an identity and persona, then execute a task. Ensure the LMKit library and a compatible language model are loaded.

```csharp
using LMKit.Model;
using LMKit.Agents;
// Load a language model
using var model = LM.LoadFromModelID("qwen3:8b");
// Create an agent with an identity
var agent = new Agent(
new AgentIdentity(
persona: "Technical Documentation Writer",
instruction: "Write clear, concise documentation for software APIs."
),
model
);
// Run a task
var result = agent.Run("Explain what a REST API is in two sentences.");
if (result.IsSuccess)
{
Console.WriteLine(result.Content);
}
```

--------------------------------

### SkillResource RelativePath Property

Source: https://docs.lm-kit.com/lm-kit-net/api/LMKit.Agents.Skills.SkillResource.RelativePath.html

Gets the path of this resource relative to the skill root directory. Example: `scripts/validate.py` or `references/API.md`.

```csharp
public string RelativePath { get; }
```

--------------------------------

### Clone the LM Kit .NET Samples

Source: https://docs.lm-kit.com/lm-kit-net/guides/samples-overview/chat-with-pdf-demo.html

Download the sample project to your local machine. This includes the chat-with-pdf demo.

```Shell
git clone https://github.com/LM-Kit/lm-kit-net-samples
cd lm-kit-net-samples/console_net/document-intelligence/chat-with-pdf/interactive_pdf_qa
__Shell__
```

--------------------------------

### Running the Semantic Search Demo Application

Source: https://docs.lm-kit.com/lm-kit-net/guides/samples-overview/embeddings-demo.html

Clone the lm-kit-net-samples repository and navigate to the text_similarity_ranker directory to run the application. This sets up the environment for the semantic search demo.

```bash
git clone https://github.com/LM-Kit/lm-kit-net-samples
cd lm-kit-net-samples/console_net/rag-and-knowledge/embeddings/text_similarity_ranker
dotnet run
```

--------------------------------

### C# Architecture Property

Source: https://docs.lm-kit.com/lm-kit-net/api/LMKit.Model.ModelCard.Architecture.html

Gets or sets the architecture type of the model. Example types include 'llama', 'bert', 'phi3'.

```csharp
public string Architecture { get; set; }
```

--------------------------------

### Using SkillContext Instructions

Source: https://docs.lm-kit.com/lm-kit-net/api/LMKit.Agents.Skills.SkillContext.Instructions.html

Example demonstrating how to retrieve a skill's instructions and incorporate them into a prompt.

```csharp
var context = activator.Activate("code-review");
string prompt = $"Follow these instructions:\n{context.Instructions}";
```

--------------------------------

### Arguments Property

Source: https://docs.lm-kit.com/lm-kit-net/api/LMKit.Mcp.Transport.StdioTransportOptions.Arguments.html

Gets or sets the command-line arguments to be passed to the process. These arguments are provided as-is to the process start information.

```APIDOC
## Arguments Property

### Description
Gets or sets the command-line arguments to be passed to the process. These arguments are provided as-is to the process start information.

### Property Type
string

### Usage
```csharp
public string Arguments { get; set; }
```

### Examples
```csharp
// For: npx @modelcontextprotocol/server-filesystem /tmp
options.Command = "npx";
options.Arguments = "@modelcontextprotocol/server-filesystem /tmp";

// For: python -m myserver --verbose
options.Command = "python";
options.Arguments = "-m myserver --verbose";
```
```

--------------------------------

### Run Graph Orchestration Showcase Demo

Source: https://docs.lm-kit.com/lm-kit-net/guides/samples-overview/graph-orchestration-showcase-demo.html

Navigate to the demo directory and run the .NET application to start the graph orchestration showcase. The default model will download on first run.

```bash
cd demos/console_net/ai-agents/graph-orchestration/graph_orchestration_showcase
dotnet run -c Release
__Shell__
```

--------------------------------

### Password Property C# Example

Source: https://docs.lm-kit.com/lm-kit-net/api/LMKit.Agents.Tools.BuiltIn.Net.FtpToolOptions.Password.html

Gets or sets the default password for FTP operations. This value can be overridden on a per-operation basis.

```csharp
public string Password { get; set; }
```

--------------------------------

### SkipReason Property C# Example

Source: https://docs.lm-kit.com/lm-kit-net/api/LMKit.Agents.Orchestration.BeforeAgentExecutionEventArgs.SkipReason.html

Gets or sets the reason for skipping an agent's execution. This property is of type string.

```csharp
public string SkipReason { get; set; }
```

--------------------------------

### Example: Importing Multiple Texts with RagEngine

Source: https://docs.lm-kit.com/lm-kit-net/api/LMKit.Retrieval.RagEngine.ImportText.html

Demonstrates how to initialize a RagEngine and import a list of texts with corresponding section identifiers into a DataSource. Ensure the number of section identifiers matches the number of texts.

```csharp
LM embeddingModel = LM.LoadFromModelID("embeddinggemma-300m");
RagEngine ragEngine = new RagEngine(embeddingModel);

var texts = new List<string>
{
    "Chapter 1: Introduction to machine learning.",
    "Chapter 2: Supervised learning techniques."
};
var sectionIds = new List<string> { "chapter1", "chapter2" };

DataSource ds = ragEngine.ImportText(
    data: texts,
    dataSourceIdentifier: "textbook",
    sectionIdentifiers: sectionIds);__C#__
```

--------------------------------

### Run Qdrant Locally with Docker

Source: https://docs.lm-kit.com/lm-kit-net/guides/samples-overview/single-turn-rag-qdrant-demo.html

Starts a Qdrant vector database instance using Docker. Ensure Docker is installed and running.

```Shell
docker run -p 6333:6333 -p 6334:6334 qdrant/qdrant

```

--------------------------------

### Create and Configure .NET Project

Source: https://docs.lm-kit.com/lm-kit-net/guides/how-to/build-multilingual-audio-translation-pipeline.html

Initializes a new .NET console project and adds the LM-Kit.NET package. This is the first step to setting up the translation pipeline.

```bash
dotnet new console -n AudioTranslationPipeline
cd AudioTranslationPipeline
dotnet add package LM-Kit.NET
```

--------------------------------

### Creating and Running a Simple Agent

Source: https://docs.lm-kit.com/lm-kit-net/api/LMKit.Agents.Agent.html

Example demonstrating how to create an Agent with a persona and instruction, and then run a task using it.

```csharp
using LMKit.Model;
using LMKit.Agents;

// Load a language model
using var model = LM.LoadFromModelID("qwen3:8b");

// Create an agent with an identity
var agent = new Agent(
    new AgentIdentity(
        persona: "Technical Documentation Writer",
        instruction: "Write clear, concise documentation for software APIs."
    ),
    model
);

// Run a task
var result = agent.Run("Explain what a REST API is in two sentences.");

if (result.IsSuccess)
{
    Console.WriteLine(result.Content);
}
```

--------------------------------

### HasMore Property C# Example

Source: https://docs.lm-kit.com/lm-kit-net/api/LMKit.Mcp.Abstractions.McpCompletionResult.HasMore.html

Gets or sets whether more completions are available beyond the returned values. This property is of type bool.

```csharp
public bool HasMore { get; set; }
```

--------------------------------

### Create and Configure a New Console Project

Source: https://docs.lm-kit.com/lm-kit-net/guides/how-to/extract-chart-data-with-vlm-ocr.html

Sets up a new .NET console application and adds the necessary LM-Kit.NET package. This is the initial step for any project using the library.

```shell
dotnet new console -n ChartExtraction
cd ChartExtraction
dotnet add package LM-Kit.NET

```

--------------------------------

### DetectedEntityKind Property

Source: https://docs.lm-kit.com/lm-kit-net/api/LMKit.Extraction.TextExtractionElement.DetectedEntityKind.html

Gets the semantic entity kind that was automatically detected from the element name and type (for example, EmailAddress, Iban, or PhoneNumber).

```APIDOC
## Property DetectedEntityKind

### Description
Gets the semantic entity kind that was automatically detected from the element name and type (for example, EmailAddress, Iban, or PhoneNumber).

### Property Value
**EntityKind** - The detected EntityKind, or Unknown when the name does not match any known entity pattern.

### C# Example
```csharp
var el = new TextExtractionElement("CustomerEmail", ElementType.String);
Console.WriteLine(el.DetectedEntityKind); // EmailAddress
```
```

--------------------------------

### Get StartPage Property Value

Source: https://docs.lm-kit.com/lm-kit-net/api/LMKit.Extraction.DocumentSegment.StartPage.html

Retrieves the 1-based page number where the document segment starts. This property is read-only and returns an integer.

```C#
public int StartPage { get; }
```

```C#
DocumentSegment segment = result.Segments[0];
Console.WriteLine($"First document starts at page {segment.StartPage}");
```

--------------------------------

### Load and Register Skill Example

Source: https://docs.lm-kit.com/lm-kit-net/api/LMKit.Agents.Skills.SkillRegistry.LoadAndRegister.html

Demonstrates how to load and register a skill from a local directory using the SkillRegistry. The loaded skill's name is then printed to the console.

```csharp
var registry = new SkillRegistry();
var skill = registry.LoadAndRegister("./skills/code-review");
Console.WriteLine($"Loaded and registered: {skill.Name}");
```

--------------------------------

### Create and Configure .NET Project

Source: https://docs.lm-kit.com/lm-kit-net/guides/how-to/build-document-monitoring-agent.html

Creates a new .NET console application and adds the LM-Kit.NET package. This is the initial setup for the document monitoring agent.

```bash
dotnet new console -n DocumentMonitor
cd DocumentMonitor
dotnet add package LM-Kit.NET
```
Tokens:
Raw