xieguigang/LLMs

This system is a multi-language toolkit for integrating and managing Large Language Models, primarily targeting R and .NET environments. It provides client libraries for interacting with local and remote LLM providers like Ollama and ChatGLM, featuring capabilities for chat, tool calling, and retrieval-augmented generation. The system also includes specialized modules for text generation using Hidden Markov Models and Llama-2, alongside a demo application for training small language models and a WebView2-based user interface for chat interactions.

17 changes.

This period focused on establishing the core infrastructure for an R-based AI agent package, featuring initial releases, CSV data handling, and integrations with ChatGLM and Ollama services. It also involved implementing local inference capabilities for Llama-2 and Hidden Markov Models, alongside comprehensive documentation and type definitions for both R and TypeScript consumers.

16 changes.

This period focused on building a comprehensive Ollama client with multi-provider support, function calling, and RAG capabilities. It also introduced a skill system for dynamic tool execution, long-term memory persistence, and a WebView2-based chat UI. Additionally, a separate TalkBuddy project was created to demonstrate a full training pipeline for small language models.

New files in src/Agent introduce support for the ChatGLM and Ollama LLM providers. ChatGLM.vb adds batch translation capabilities, allowing users to submit multiple translation tasks via a dataframe and parse the resulting JSON responses, including optional annotations. GLMBatchTask.vb defines the data structures for these batch requests and results. OLlama.vb provides an Ollama client wrapper with APIs to create clients, configure system messages, retrieve model information, perform chat interactions, and register custom function tools for agent use. zzz.vb registers the module as an R package.

src/Agent · high confidence

New VB.NET classes (History, RequestBody, ResponseBody) are added to the Ollama JSON namespace to define the structure of API requests and responses. These models support message history with roles (user, assistant, system, tool), tool calls, streaming options, and response metadata such as token counts, enabling the client to serialize and deserialize Ollama API interactions.

src/Ollama/JSON · high confidence

The documentation site now includes generated reference pages for several new API areas. This adds documentation for the \Agent.ChatGLM\ namespace (including \ChatHistory\ and \GLMBatchTask\), the \Ollama\ namespace (covering JSON structures like \RequestBody\, \History\, and \FunctionCall\ types, as well as \DeepSeekResponse\), and the \Microsoft.VisualBasic.CommandLine\ namespace (detailing the \Interpreter\, reflection types like \APIEntryPoint\, and delegate types). It also adds documentation for \Microsoft.VisualBasic.ApplicationServices.Debugging.Diagnostics\ types (\Method\, \StackFrame\, \MSG\_TYPES\) and \Microsoft.VisualBasic.Scripting.MetaData\ attributes (\PackageAttribute\, \APICategories\).

vignettes/clr · high confidence

New R documentation pages have been added to the ChatGLM package vignettes, covering batch translation tasks, history JSON building, input/response recording, and batch output parsing.

vignettes/Agent/chatglm · high confidence

The Talk module now includes two new text generation approaches. First, it adds a local Llama-2 inference engine (src/Talk/Llama2.vb and src/Talk/Llama2Models/) that loads model checkpoints and tokenizers, supporting configurable temperature, top-p sampling, and step limits for streaming token output. Second, it introduces a Hidden Markov Model (HMM) based generator (src/Talk/HMM/Corpora.vb, Generator.vb, TalkFunction.vb) that builds a word graph from input text and generates sentences using a roulette-selection algorithm with optional temperature control, exposed via a SimpleTalker helper.

src/Talk · high confidence

Added man pages for the Ollama agent, including functions to create a new client, chat with LLMs, set system messages, add tools, and retrieve model information.

man/Agent/ollama · high confidence

New HTML documentation pages have been added for the ollama package, covering functions such as \add\_tool\, \chat\, \deepseek\_chat\, \get\_modelinfo\, \new\, \setup\_global\_hook\, and \system\_message\. These pages provide usage details, argument descriptions, and return value types for the Ollama client integration.

vignettes/Agent/ollama · high confidence

New static assets have been added to the vignettes directory to enable syntax highlighting for R code examples. This includes an R-specific tokenizer (R\_syntax.js) defining keywords, operators, and color literals, a helper script (highlights.js) to apply these styles to code blocks, and a stylesheet (page.css) that defines the visual classes for comments, numbers, keywords, and other R language elements.

_vignettes/\assets · high confidence

New TypeScript declaration files have been added to the @export package to provide type definitions for JavaScript/TypeScript consumers. These files expose the \chatglm\ namespace (including batch translation and history parsing functions), the \ollama\ namespace (covering chat, tool addition, and client setup), and the \LLMs\ namespace (providing the \agent\_readcsv\ function and \onLoad\ hook), enabling proper IntelliSense and type checking for these agent integrations.

@export · high confidence

New HTML vignette pages have been added for the Agent module, documenting the ChatGLM and Ollama integrations. The ChatGLM page details the \chat\_history\ helper and functions for managing input/response records, JSON history building, and batch translation tasks. The Ollama page documents the client creation, global API hooks, model information retrieval, system message management, chat capabilities, and tool addition.

vignettes/Agent · high confidence

Introduced src/ollama\_rag.py, a new module that implements a Retrieval-Augmented Generation (RAG) proxy using Ollama. This component provides a local VectorDB for storing and retrieving document chunks via cosine similarity, handles text chunking, and integrates with Ollama for generating embeddings and LLM responses, enabling local AI-driven document search capabilities.

python · high confidence

New scripts have been added to the .pkg directory to streamline the packaging workflow. The build.cmd script automates the creation of an R package archive using Rscript and installs it locally, while publish.R provides a mechanism to push generated .nupkg files to a NuGet source, requiring an API key and source name as arguments.

.pkg · high confidence

New documentation files have been added to the man directory, including man pages for the .onLoad function (with a quietly parameter) and the agent\_readcsv function (which reads CSV files and returns JSON-encoded row data). An index.json file has also been created to map these functions, providing structured metadata such as source file locations (zzz.R and read.csv.R) and parameter descriptions for programmatic access.

man · high confidence

Added documentation (man pages) for the ChatGLM agent module, covering functions for managing chat history (\input\_and\_response\, \history\_json\), processing batch translation tasks (\batch\_transaltion\), and parsing batch results (\parse\_batch\_output\).

man/Agent/chatglm · high confidence

The vignettes directory now includes an index page (index.html) that lists the LLMs package metadata and provides links to specific function documentation (such as agent\_readcsv and .onLoad) as well as library symbols (chatglm, ollama). A new keywords.html page has also been added to display symbols grouped by shared keywords and topics.

vignettes · high confidence

This change introduces the foundational structure for an R-based AI agent. It adds a new \read.csv.R\ module that provides a \read\_csv\ function, allowing users to load CSV files and return the data as JSON-encoded text. Additionally, it includes a \zzz.R\ file that handles package initialization by importing the \chatglm\ agent component upon loading.

R · high confidence

This change introduces the initial structure for the 'LLMs' R package (version 0.1.0), providing tools for processing Large Language Models. The package is licensed under MIT and includes configuration files (DESCRIPTION, NAMESPACE) and an RStudio project file. It also updates the .gitignore to exclude build artifacts and user-specific files, and replaces the previous GNU GPL license with the MIT license.

(repo-wide) · high confidence

This change adds a new Hidden Markov Model (HMM) implementation in \src/HMM\, providing core classes for model definition, validation, and statistical operations (forward, backward, Viterbi, and Baum-Welch algorithms). It also includes utilities for parsing HMM parameters from JSON and a test project that demonstrates integration with local LLM services (Ollama) for chat, streaming, and function calling, alongside examples for HMM-based text generation.

src/HMM · high confidence

Added a new SkillSystem in the Ollama module that enables the LLM to dynamically discover, match, and execute external skills defined by SKILL.md files. The system uses a three-layer progressive disclosure mechanism: Layer 1 scans and caches lightweight YAML metadata at startup for intent classification; Layer 2 loads the full skill definition (instructions, input/output specs, constraints) only when a relevant skill is matched; and Layer 3 allows the LLM to execute sandboxed scripts (Python, Bash, PowerShell, etc.) via a function-call tool during task execution. This allows users to extend the Ollama client's capabilities by installing custom skills that the LLM can invoke on demand.

src/Ollama/SkillSystem · high confidence

Added new VB.NET classes in the Ollama JSON FunctionCall namespace to support structured function calling. The FunctionModel, FunctionParameters, and ParameterProperties classes define the schema for function definitions, including name, description, and typed arguments with optional defaults. The FunctionTool class provides a factory method to create tool sets from function models. Additionally, the Invoke.vb file introduces ToolCall and FunctionCall classes to represent the invocation of a function, including the function name, arguments as a dictionary, and helper methods to check for argument existence and access arguments by name or index.

src/Ollama/JSON/FunctionCall · high confidence

This change adds a new Windows Forms application (FormLLMUI) that hosts a WebView2 control to display a web-based chat interface for interacting with local LLM backends (such as Ollama). The UI supports streaming token output, markdown rendering, and the attachment of multiple files to the chat context. Users can view or remove attached files directly from the interface, and the application allows customizing the topbar logo and assistant avatar via image sources.

src/WebView2UI · high confidence

Chat sessions now support saving and loading conversation history to local JSON files, ensuring context survives application restarts. Additionally, messages evicted from the active context window due to token limits are automatically archived to a separate JSONL file and indexed for fuzzy keyword search, allowing the system to recall relevant past interactions even after they have been trimmed from the immediate conversation.

src/Ollama/ContextMemory · high confidence

Adds the TalkBuddy demo application, which implements a full training pipeline for a small language model using the DeepSeek tokenizer. This includes a ChatTemplate for converting dialogue messages into token sequences with loss masking, synthetic data generators for pre-training (EmbeddedCorpus), instruction tuning (SftSynthesizer), and tool calling (ToolCallSynthesizer), and a DemoPipeline that orchestrates the three-stage training process (pre-training, SFT, tool SFT) with configurable model scales and CUDA support.

src/TalkBuddy · high confidence

Added a new OllamaProxyServer component that acts as an HTTP proxy for Ollama, exposing an OpenAPI-compatible /v1/chat/completions endpoint. The server intercepts chat requests, performs a placeholder RAG search to augment the user's last message with context from a knowledge base, and forwards the modified request to the local Ollama instance (defaulting to http://localhost:11434/api/generate). Responses are streamed back to the client as Server-Sent Events (SSE). The RAG implementation is currently a stub returning 'hello world'.

src/OllamaProxy · high confidence

Added a new set of components in src/Ollama/ToolCalls to handle function calling for Ollama models. This includes CLRFunction.vb for mapping .NET methods to tool definitions and invoking them with dynamic type casting, LlmJsonExtractor.vb for robustly extracting and repairing JSON from LLM responses (including handling markdown blocks and truncated output), DSML.vb for parsing DeepSeek-specific DSML format tool calls, FunctionCaller.vb as a registry and dispatcher for registered tools, and ToolArgument.vb for defining tool argument metadata.

src/Ollama/ToolCalls · high confidence

Added three new solution files (LLMs.slnx, Ollama.slnx, TalkBuddy.slnx) that define build configurations and project references for the LLM agent, Ollama integration, and TalkBuddy applications, including dependencies on framework components like NLP, JSON, Markdown, and WebView2.

src · high confidence

A change to existing behaviour in data — 1 commit, 2 files.

data · medium confidence · unverified

File attachment references have been refactored into dedicated FileReference objects that include a stable unique identifier (uid) independent of the file path, enabling reliable deletion and viewing of specific attachments. The system now supports both disk-based files and in-memory data via a new MemoryReference class, allowing users to preview text content with truncation handling for large files. A new FileViewRequestEventArgs class provides a mechanism for the host application to intercept and handle file view requests, giving control over whether files are opened with the system default program or displayed in a modal dialog.

src/WebView2UI/FileSystem · high confidence

The Ollama module now features a unified LLM client that supports both local Ollama instances and OpenAI-compatible APIs (such as DeepSeek) through a common interface. This change introduces a provider abstraction allowing users to switch backends via URL schemes (e.g., \openai://\ or \ollama://\) and provides detailed usage statistics, including KV cache hit/miss rates for supported backends. The client also standardizes response handling to separate 'think' (reasoning) content from output, supports tool calling with round limits, and manages chat context memory.

src/Ollama · high confidence

Added LLM algorithm demo and validation tests; Added Methoxamine datasheet for test data; Added demo programs for SkillSystem and Memory persistence.

The project files for Agent, HMM, Ollama, OllamaProxy, Talk, TalkBuddy, WebView2UI, and their associated test projects have been updated to target .NET 10.0 (with Windows-specific variants like net10.0-windows where applicable). This shift from previous versions (such as .NET 8.0 seen in HMM) aligns the solution with the latest .NET runtime, enabling access to new language features and performance improvements while maintaining compatibility with existing internal dependencies like NLP.NET and sciBASIC.

(dependencies) · high confidence

Written by watchdog.canine.dev from the codebase's own history, inside the signed delivery this page is composed from.

• First survey — no prior run to compare against. CAI 55.

• Code Health 91
• Architecture 98
• Maturity 59
• Readiness 30
• Security 100

• 300 commits — 266 feature/other, 34 fixes

• src/Ollama — 125 commits
• src/WebView2UI — 56 commits
• src/Agent — 24 commits
• src/TalkBuddy — 20 commits
• src/Researcher — 12 commits
• man/.onLoad.1 — 10 commits
• src/HMM — 8 commits
• man/Agent — 7 commits
• (root) — 6 commits
• src/.codebuddy — 5 commits
• @export/index.d.ts — 3 commits
• src/HMM.sln — 3 commits
• vignettes/clr — 3 commits
• @export/ollama.d.ts — 2 commits
• src/Example.vb — 2 commits
• src/LLMs.slnx — 2 commits
• src/Ollama.slnx — 2 commits
• src/OllamaProxy — 2 commits
• src/Talk — 2 commits
• src/ollama_rag.py — 2 commits

• fix: Fix token flush timer and host method calls
• fix: fix bug about check deepseek tool call info
• fix: fix bugs about missing paramneter aarguments value
• fix: fix for load ui
• fix: fix for parse message strream for ollama backend
• fix: fix for the webview ui framework
• fix: fix of adamw reference error
• fix: fix of the argument attribute tag
• fix: fix of the data object reference error
• fix: fix of the get argument by offset
• fix: fix of the list type serialization to json
• fix: fix of the loop
• fix: fix of the method referenc errror
• fix: fix of the missing code span reference
• fix: fix of the missing componentsd
• fix: fix of the namespace reference error
• fix: fix of the object reference error
• fix: fix of the possible tool call error
• fix: fix of the rscript api exports
• fix: fix of the simd math overflows
• …and 280 more

• 0 containers · 1 bounded contexts · 0 dependency edges (baseline)

Written by watchdog.canine.dev from the codebase's own history, inside the signed delivery this page is composed from.

xieguigang/LLMs was measured the same way every project in this corpus was: the same rubric, at a pinned commit, with the result published in full. Point a surveyor at a repository you know and see whether you agree with it.