Skip to content
CAI
Software that uses CAICheck a score

xieguigang/LLMs

39.7

Weak · 7 November 2026

22.2k

lines of production code

VB.NET

with JavaScript

4

measurements over time

CAI band scale
CAI trend line
CAI lens gauges

What this system is

Features

Add CSV reading agent and package initialization

The package now includes a new \read.csv\ agent function that reads a CSV file from a given filepath and returns the data as a JSON-encoded string, with rows represented as JSON objects. Additionally, the package initialization file (\zzz.R\) has been added to import the \chatglm\ agent upon loading, establishing the foundation for LLM-based agent interactions within the R environment.

R · high confidence

Add Ollama agent documentation

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

man/Agent/ollama · high confidence

Added .NET CLR documentation for ChatGLM, Ollama, and Visual Basic CommandLine types

The documentation site now includes generated reference pages for several new .NET CLR types. This adds API documentation for the \Agent.ChatGLM\ namespace (including \ChatHistory\ and \GLMBatchTask\), the \Ollama\ namespace (covering \DeepSeekResponse\, \RequestBody\, \History\, and the \FunctionCall\ sub-namespace with \FunctionModel\, \FunctionParameters\, \FunctionTool\, \ToolCall\, and \FunctionCall\), and the \Microsoft.VisualBasic.CommandLine\ namespace (including the \Interpreter\, \ExecuteEmptyCLI\, \ExecuteFile\, \ExecuteNotFound\, \ExecuteQuery\ delegates, and reflection types like \APIEntryPoint\, \APIDelegate\, \ArgumentCollection\, and \Namespace\). It also adds documentation for \Microsoft.VisualBasic.ApplicationServices.Debugging.Diagnostics\ (\Method\, \StackFrame\), \Microsoft.VisualBasic.ApplicationServices.Debugging.Logging\ (\MSG\_TYPES\), \Microsoft.VisualBasic.ComponentModel.DataSourceModel\ (\IDynamicsObject\), and \Microsoft.VisualBasic.Scripting.MetaData\ (\APICategories\, \PackageAttribute\).

vignettes/clr · high confidence

Added ChatGLM agent documentation vignettes

New R documentation pages have been added for the \chatglm\ package, covering batch translation tasks (\batch\_transaltion\), history management (\history\_json\, \input\_and\_response\), and result parsing (\parse\_batch\_output\). These vignettes provide usage examples and argument details for interacting with the ChatGLM agent, including creating JSON data for batch tasks and parsing batch request outputs.

vignettes/Agent/chatglm · high confidence

Added Ollama RAG proxy with local vector storage

Introduced src/ollama\_rag.py, a new module that implements a Retrieval-Augmented Generation (RAG) proxy using Ollama. This component provides a local vector database (persisted to JSON) for storing document chunks and embeddings, supports text chunking with configurable overlap, and integrates with Ollama for generating embeddings and interacting with LLMs like deepseek-r1:8b. It exposes an asynchronous API for processing documents and performing similarity searches based on cosine similarity.

python · high confidence

Added R documentation vignettes for the ollama package

New HTML documentation pages have been added to the vignettes/Agent/ollama directory, covering the package's core functions: \new\ (client creation), \chat\ (LLM interaction), \deepseek\_chat\ (specific model support), \add\_tool\ (tool registration), \system\_message\ (context management), \get\_modelinfo\ (model details), and \setup\_global\_hook\ (API hooks). These pages provide usage signatures, argument descriptions, and return value types for users of the ollama R package.

vignettes/Agent/ollama · high confidence

Added R syntax highlighting assets for vignettes

New static assets have been added to the vignettes to enable syntax highlighting for R code examples. This includes \R\_syntax.js\ which defines tokenization rules and color mappings for R keywords, operators, and literals; \highlights.js\ which applies these styles to code blocks in the DOM; and \page.css\ which provides the visual styling for code, comments, and other vignette elements.

_vignettes/\assets · high confidence

Added TypeScript type definitions for ChatGLM, Ollama, and LLMs agent modules

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

Added documentation for ChatGLM and Ollama agent integrations

New documentation pages have been added for the ChatGLM and Ollama agent integrations within the R\# LLMs package. The ChatGLM page details helper functions for managing chat history, including input/response recording, JSON serialization, and batch translation processing. The Ollama page documents the client API, covering client initialization, global hooks, model information retrieval, system message configuration, chat interactions, tool addition, and specific support for DeepSeek models.

vignettes/Agent · high confidence

Added local build and NuGet publishing scripts

New scripts have been added to the .pkg directory to streamline the packaging workflow. build.cmd automates the creation of an R package archive using Rscript and installs it locally, while publish.R iterates through generated .nupkg files in the .nuget directory and pushes them to a specified NuGet source using the provided API key.

.pkg · high confidence

Added man pages and documentation index for .onLoad and agent\_readcsv

The package now includes manual pages and a documentation index for the \.onLoad\ function and the \agent\_readcsv\ utility. The \.onLoad\ page documents the \quietly\ parameter, while the \agent\_readcsv\ page explains that the function accepts a CSV file path and returns the data as JSON-encoded text. An \index.json\ file has also been added to map these functions for documentation lookup.

man · high confidence

Added man pages for ChatGLM batch processing and history functions

New manual pages have been added for the ChatGLM agent module, documenting four specific functions: \input\_and\_response\ for recording chat history, \history\_json\ for building JSON history strings, \batch\_transaltion\ for creating JSON data for batch translation tasks, and \parse\_batch\_output\ for parsing batch request results. These pages provide usage details and parameter descriptions for the underlying Agent.dll components.

man/Agent/chatglm · high confidence

Added package documentation vignettes

New vignette files have been added to the documentation site. The index page now lists the LLMs package details and provides navigation to specific symbols like agent\_readcsv and .onLoad, as well as library components such as chatglm and ollama. A keywords page has also been added to help users browse symbols by shared topics.

vignettes · high confidence

Adds Llama-2 inference and HMM-based text generation capabilities

The \src/Talk\ area now includes new components for AI-driven text generation. It introduces a local inference engine for Llama-2 models (\Llama2.vb\, \Llama2Models/\), enabling users to load model checkpoints and generate text with configurable temperature, top-p sampling, and step limits. Additionally, it adds a statistical language model layer (\HMM/\) featuring a \Corpora\ class for building word-transition graphs and a \Generator\ for producing text sequences based on those probabilities, accessible via a \SimpleTalker\ helper.

src/Talk · high confidence

Initial release of LLMs R package with Hidden Markov Model tools

This change introduces the initial structure for the 'LLMs' R package (version 0.1.0), providing tools for processing Hidden Markov Models (HMMs). The package includes core configuration files (DESCRIPTION, NAMESPACE) and adapts a Visual Basic HMM implementation from the 'AhmedHani/Hidden-Markov-Model' repository, exposing algorithms such as Brute Force, Forward-backward, Viterbi, and Baum-Welch. It also adds support for reading HMM models from JSON files and includes a project file (LLMs.Rproj) and updated build ignore rules to support the new R package structure.

(repo-wide) · high confidence

Introduce Hidden Markov Model library and Ollama integration tests

This change adds a new Hidden Markov Model (HMM) implementation in \src/HMM\, including core model logic, JSON parsing, data decoding, and validation utilities. It also introduces a test suite that demonstrates integration with Ollama local LLMs (e.g., deepseek-r1, qwen3) for chat, streaming, and function calling, alongside text generation examples using HMM-based state machines.

src/HMM · high confidence

Introduce LLM harness sandbox tools for file system operations

Added a suite of new tools in src/Harness/Tools that allow the LLM agent to interact with the file system within a sandboxed environment. These include ApplyPatchTool for all-or-nothing patch application, DeleteTool for removing files and directories, EditTool for literal text replacement, GlobTool for pattern-based file discovery, GrepTool for content searching with ripgrep-style regex, LsTool for directory listing, and MoveTool for renaming or moving files. All tools enforce sandbox security policies, resolve paths against the workspace, and support a one-shot permission escalation mechanism for denied operations.

src/Harness/Tools · high confidence

Introduce Ollama JSON data models for chat history and request/response bodies

Added new VB.NET classes in the Ollama JSON namespace to structure data for the Ollama API. The History class defines message roles (user, assistant, system, tool) and content, supporting tool calls. The RequestBody class models outgoing requests, including model selection, message history, streaming options, and tool definitions. The ResponseBody class structures incoming responses, capturing the generated message, completion status, and token usage statistics (prompt and evaluation counts).

src/Ollama/JSON · high confidence

Introduce WebView2-based LLM chat UI with file attachment support

A new Windows Forms application (FormLLMUI) has been added 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 with configurable flush intervals, markdown rendering for model responses, and the ability to attach multiple files to the conversation 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

Introduce background job management tools

Added a new set of tools for managing long-running background work within the session. Users can now start background shell commands or natural language tasks via \job\_start\, monitor their progress and output with \job\_output\, view all active and finished jobs with \job\_list\, and terminate running jobs using \job\_kill\. This allows the conversation to remain responsive while heavy work executes in the background, with output streamed incrementally for commands or returned as a final result for tasks.

src/Harness/Job · high confidence

Introduce the SkillSystem harness for LLM-driven skill execution

The SkillSystem module has been added to the Harness project, providing a three-layer progressive disclosure mechanism for executing user tasks via an LLM. Layer 1 scans installed skills to cache lightweight metadata (name, description, tags) for intent classification. Layer 2 loads the full skill definition (SKILL.md) only when a relevant skill is matched, parsing structured sections like execution flow and constraints. Layer 3 enables the LLM to invoke scripts and resources on demand via a sandboxed script executor, which runs commands in child processes with path traversal protection and output capture. The system includes a SkillAgent orchestrator, a SkillManager for coordination, and support for declarative manifests (manifest.yaml) to define always-load files, on-demand resources, and execution axes.

src/Harness/SkillSystem · high confidence

Introduces TalkBuddy LLM demo with three-stage training pipeline

Adds the TalkBuddy demo application, which implements a complete three-stage training pipeline (pre-training, instruction SFT, and tool-calling SFT) for a small language model. The change includes a DeepSeek tokenizer adapter with vocabulary remapping, a chat template engine that generates token sequences with precise loss masks for assistant responses, and programmatic synthesizers for instruction and tool-calling training data. It also provides a set of deterministic demo tools (weather, time, calculation, knowledge search) with JSON schemas, a configurable model architecture supporting Mixture of Experts (MoE) and KV Cache, and console reporting utilities for monitoring training metrics.

src/TalkBuddy · high confidence

Introduces structured tool call logging, sandbox security policies, and user interaction tools

The Harness now records every tool invocation in a structured JSON log (tool-calls.json, tools.json, permissions.json, session.json) under the workspace's .harness folder, capturing arguments, results, timing, and status for debugging. A new security framework enforces workspace boundaries via SecurityPolicy (Readonly, AskPermission, FullControls) and requires user consent for out-of-bounds write or execute operations through a RequestPermission event. Additionally, the system supports asynchronous user interaction via the ask\_user\_question tool, allowing the model to pause for confirmations or choices in both blocking and timed modes, and includes new web search and fetch capabilities powered by the DeepSeek API.

src/Harness · high confidence

Long-term memory persistence and fuzzy retrieval for chat context

The Ollama context memory system now supports saving and loading chat history to JSON files, and archiving evicted messages to a separate JSONL file for long-term storage. Evicted messages are indexed using a Q-gram full-text search engine, allowing the LLM to recall forgotten context via keyword-based fuzzy retrieval. The context manager also introduces a 'Compress' mode that uses an LLM to summarize old messages instead of simply trimming them, and ensures tool-call messages are kept together during context management.

src/Ollama/ContextMemory · high confidence

New ChatGLM batch translation and Ollama LLM client integration

Added support for batch translation tasks via the ChatGLM API, including utilities to construct batch payloads and parse JSONL results into dataframes with optional annotation extraction. Introduced an Ollama client wrapper that allows creating LLM instances, setting system messages, retrieving model information, and performing chat with optional function calling support.

src/Agent · high confidence

New Harness Log Viewer for inspecting agent sessions

Users can now inspect detailed logs from agent sessions directly within the application using a new Harness Log Viewer. This feature introduces a dedicated UI for browsing and filtering session data, supporting both tool call logs (under 'toolcalls') and LLM chat logs (under 'llm-sessions'). The viewer provides a paginated interface to view specific records like tool calls, permissions, and messages, along with a JSON tree view for raw data inspection. It includes a self-test capability to verify the integrity of the log data layer against real \.harness\ folders.

src/WebView2UI/Logs · high confidence

New MCP client and tool bridge for the Harness

The Harness now includes a complete Model Context Protocol (MCP) client implementation in src/Harness/MCP. This adds support for connecting to MCP servers via both stdio (local child processes) and Streamable HTTP transports, handling the MCP handshake, request/response correlation, and error management. The new McpToolBridge component automatically discovers tools, prompts, and resources from connected servers and registers them as callable functions on the LLM client, allowing the AI to interact with external MCP services seamlessly. Configuration is managed via a standard mcp.json file in the workspace's .harness folder.

src/Harness/MCP · high confidence

New Ollama proxy server with RAG-augmented chat completions

A new OllamaProxyServer component has been added to forward OpenAI-compatible /v1/chat/completions requests to a local Ollama instance. The server intercepts user messages, augments them with context from a placeholder RAG search function, and streams the response back to the client as Server-Sent Events (SSE). It includes a health check endpoint and handles basic HTTP method validation.

src/OllamaProxy · high confidence

New Ollama tool-calling infrastructure with robust JSON parsing and type mapping

Added a new tool-calling subsystem in src/Ollama/ToolCalls that enables the Ollama integration to invoke registered functions based on LLM responses. The system includes CLRFunction.vb to map .NET methods to tool definitions with automatic parameter type mapping (e.g., String→string, Integer→integer) and argument extraction, FunctionCaller.vb to manage and execute registered function calls, LlmJsonExtractor.vb to robustly extract and repair JSON from LLM responses (handling markdown blocks, truncated JSON, and malformed input via LenientJsonParser), DSML.vb to parse DeepSeek-specific DSML format tool calls, and ToolArgument.vb as the data model for tool arguments. This provides a foundation for structured function calling with Ollama models.

src/Ollama/ToolCalls · high confidence

New function call model and invocation classes for Ollama JSON handling

Added new VB.NET classes in the Ollama JSON FunctionCall namespace to support structured function calling. FunctionModel, FunctionParameters, and ParameterProperties define the schema for function definitions and their arguments, including support for default values and type specifications. FunctionTool provides a factory method to create tool sets from function models. Invoke.vb introduces ToolCall and FunctionCall classes to represent the execution of a function, including argument access by name or index, existence checks, and string representation for debugging.

src/Ollama/JSON/FunctionCall · high confidence

New solution files for LLM, Ollama, and TalkBuddy projects

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. These files establish the build structure for the new AI-related components, including references to underlying framework projects like NLP, JSON, Markdown, and WebView2 helpers.

src · high confidence

Behavioural changes

1 commit (0 fixes) modifying data

A change to existing behaviour in data — 1 commit, 2 files: “R source folder”.

data · medium confidence · unverified

Introduce WinForms log viewer as the application entry point

The application now launches a WinForms-based log viewer (FormLogViewer) as its main window instead of the previous startup configuration. This change adds the necessary Visual Basic application framework files to define the entry point, set the main form, and configure basic application settings such as visual styles and shutdown behavior.

src/WebView2UI/My Project · high confidence

Refactored file attachment handling with stable IDs and preview support

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

Unified LLM client with multi-provider support and KV cache statistics

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

Test coverage

Added LLM algorithm demo and validation tests; Added Methoxamine datasheet for test data; Added demo programs for SkillSystem and Memory persistence; Added harness self-tests for MCP client, skill system, and tool logging.

Dependencies

Projects migrate to .NET 10 and add WebView2 UI support

Multiple project files (Agent, HMM, Ollama, OllamaProxy, Talk, TalkBuddy, WebView2UI) have been updated to target .NET 10.0 (with some retaining .NET 8.0 or adding Windows-specific variants like net10.0-windows). The WebView2UI project introduces a new Windows Forms/WPF UI layer using Microsoft.Web.WebView2 version 1.0.4258.31, suppressing the WFO1000 warning. Build configurations are standardized with full debug types and specific release settings across these components.

(dependencies) · high confidence

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

How this codebase got here

Score

  • CAI 40 → 40 (-0.1)
  • Rubric changed (rubric-2026.10.5 → rubric-2026.11.2) — scores are not directly comparable.

Lenses

  • Code Health 23 → 23 (+0.0)
  • Architecture 98 → 98 (+0.0)
  • Maturity 70 → 69 (-0.5)
  • Readiness 22 → 22 (+0.0)
  • Security 100 → 100 (+0.0)
  • Performance 100 → 100 (+0.0)

Resolved (3)

  • Coverage not measured — no coverage collector is wired up
  • Hotspot: src/Ollama/ToolCalls/CLRFunction.vb (src/Ollama/ToolCalls/CLRFunction.vb)
  • Off-boarding risk: anonymized user #1

New (10)

  • Off-boarding risk: anonymized user #1
  • doc comments repeat the names (src/Agent/ChatGLM.vb)
  • doc comments repeat the names (src/HMM/Model/DataDecoding.vb)
  • doc comments repeat the names (src/HMM/Test/Module3.vb)
  • doc comments repeat the names (src/Harness/Logging/ToolCallLog.vb)
  • doc comments repeat the names (src/Ollama/LLMClient.vb)
  • doc comments repeat the names (src/Talk/Llama2Models/TransformerWeights.vb)
  • doc comments repeat the names (src/WebView2UI/LLMHost.vb)
  • redundant comment (src/Harness/Sandbox.vb)
  • redundant comment (src/Talk/Llama2.vb)

Changes since last survey

  • 2 commits — 2 feature/other, 0 fixes

By area

  • src/Ollama — 2 commits

Notable commits

  • change: Update OpenAIProvider.vb
  • change: log json parser error

Architecture

  • Unchanged — 0 containers · 1 contexts · 0 edges

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

Survey your own repository

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.

About this page

  • The score is its most recent published measurement, taken on 7 November 2026 at a pinned commit. It is not a live figure and does not change until the project is measured again.
  • Measured at commit 111b0d3f9265513a043250f701112c6a593fb10f — the exact code this score is about.
  • Scored under rubric-2026.11.2 — the same rubric and the same method as every other entry in this index.
  • Measured by Canine Code Analyzer (cca.canine.dev) using cca measure-2026.11.3+preprod-110e4fee044f.