Ollama-Buddy on Emacs@ Dyerdwelling

Ollama Buddy - Web Search Integration

James Dyer — Wed, 04 Mar 2026 09:34:00 +0000

One of the fundamental limitations of local LLMs is their knowledge cutoff - they don’t know about anything that happened after their training data ended. The new web search integration in ollama-buddy solves this by fetching current information from the web and injecting it into your conversation context. Ollama has a specific API web search section, so it has now been activated!

Here is a demonstration:

https://www.youtube.com/watch?v=05VzAajH404

The web search feature implements a multi-stage pipeline that transforms search queries into clean, LLM-friendly context, your search query is sent to Ollama’s Web Search API, the API returns structured search results with URLs and snippets.

I have decided that each URL by default is fetched and processed through Emacs’ built-in eww and shr HTML rendering, but this can of course be configured, set ollama-buddy-web-search-content-source to control how content is retrieved:

`eww’ (default): Fetch each URL and render through eww/shr for clean text
`api’: Use content returned directly from Ollama API (faster, less refined)

The shr (Simple HTML Renderer) library does an excellent job of converting HTML to readable plain text, stripping ads, navigation, and other noise, so I thought why not just use this rather than the return results from the ollama API, as they didn’t seem to be particularly accurate.

The cleaned text is formatted with org headings showing the source URL and attached to your conversation context, so when you send your next prompt, the search results are automatically included in the context. The LLM can now reason about current information as if it had this knowledge all along.

There are multiple ways to search; firstly, is inline @search() syntax in your prompts (gradually expanding the inline prompting language!), so for example:

What are the key improvements in @search(Emacs 31 new features)?
Compare @search(Rust async programming) with @search(Go concurrency model)

ollama-buddy automatically detects these markers, executes the searches, attaches the results, and then sends your prompt, so you can carry out multiple searches.

You can also manual Search and Attach, Use C-c / a (or M-x ollama-buddy-web-search-attach)

The search executes, results are attached to your session, and the ♁1 indicator appears in the header line and the results can be viewed from the attachments menu, so for example would display something like:

* Web Searches (1)
** latest Emacs 31 features
*** 1. Hide Minor Modes in the Modeline in Emacs 31
*** 2. New Window Commands For Emacs 31
*** 3. Latest version of Emacs (GNU Emacs FAQ)
*** 4. bug#74145: 31.0.50; Default lexical-binding to t
*** 5. New in Emacs 30 (GNU Emacs FAQ)

with each header foldable, containing the actual search results.

There is a little configuration required to go through the ollama API, first, get an API key from https://ollama.com/settings/keys (it’s free). Then configure:

(use-package ollama-buddy
 :bind
 ("C-c o" . ollama-buddy-role-transient-menu)
 ("C-c O" . ollama-buddy-transient-menu-wrapper)
 :custom
 ;; Required: Your Ollama web search API key
 (ollama-buddy-web-search-api-key "your-api-key-here"))

For clarification, the content source options are as follows:

The ollama-buddy-web-search-content-source variable controls how content is retrieved:

eww (default, recommended)

Fetches each URL and renders HTML through Emacs’ eww/shr. Produces cleaner, more complete content but requires additional HTTP requests.

Pros:

Much cleaner text extraction
Full page content, not just snippets
Removes ads, navigation, clutter
Works with any website

Cons:

Slightly slower (additional HTTP requests)
Requires network access for each URL

api (experimental)

Uses content returned directly from the Ollama API without fetching individual URLs. Faster but content quality depends on what the API provides.

Pros:

Faster (single API call)
Less network traffic

Cons:

Content may be truncated
Quality varies by source
May miss important context

I strongly recommend sticking with eww - the quality difference is substantial.

By default, web search fetches up to 5 URLs with 2000 characters per result. This provides rich context without overwhelming the LLM’s context window.

For longer research sessions, you can adjust:

(setq ollama-buddy-web-search-max-results 10) ;; More sources
(setq ollama-buddy-web-search-snippet-length 5000) ;; Longer excerpts

Be mindful of your LLM’s context window limits. With 5 results at 2000 chars each, you’re adding ~10K characters to your context.

The web search integration fundamentally expands what your local LLMs can do. They’re no longer limited to their training data - they can reach out, fetch current information, and reason about it just like they would with any other context, so hopefully this will now make ollama-buddy a little more useful

Ollama Buddy v2.5 - RAG (Retrieval-Augmented Generation) Support

James Dyer — Tue, 24 Feb 2026 11:50:00 +0000

One of the things that has always slightly bothered me about chatting with a local LLM is that it only knows what it was trained on (although I suppose most LLMs are like that) . Ask it about your own codebase, your org notes, your project docs - and it’s just guessing. Well, not anymore! Ollama Buddy now ships with proper Retrieval Augmented Generation support built-in

What even is RAG?

If you haven’t come across the term before, the basic idea is simple. Instead of asking the LLM a question cold, you first go off and find the most relevant bits of text from your own documents, then you hand those bits to the LLM along with your question. The LLM now has actual context to work with rather than just vibes. The “retrieval” part is done using vector embeddings - each chunk of your documents gets turned into a mathematical representation, and at query time your question gets the same treatment. Chunks that are mathematically “close” to your question are the ones that get retrieved.

In this case, I have worked to keep the whole pipeline inside Emacs; it talks to Ollama directly to contact an embedding model, which then returns the required information. I have tried to make this as Emacs Org-friendly as possible by storing the embedding information in Org files.

Getting started

You’ll need an embedding model pulled alongside your chat model. The default is nomic-embed-text which is a solid general-purpose choice:

ollama pull nomic-embed-text

or just do it within ollama-buddy from the Model Management page.

Indexing your documents

The main entry point is M-x ollama-buddy-rag-index-directory. Point it at a directory and it will crawl through, chunk everything up, generate embeddings for each chunk, and save an index file. The first time you run this it can take a while depending on how much content you have and how fast your machine is - subsequent updates are much quicker as it only processes changed files.

Supported file types (and I even managed to get pdf text extraction working!):

Emacs Lisp (.el)
Python, JavaScript, TypeScript, Go, Rust, C/C++, Java, Ruby - basically most languages
Org-mode and Markdown
Plain text
PDF files (if you have pdftotext from poppler-utils installed)
YAML, TOML, JSON, HTML, CSS

Files over 1MB are skipped (configurable), and the usual suspects like .git, node_modules, __pycache__ are excluded automatically.

The index gets saved into ~/.emacs.d/ollama-buddy/rag-indexes/ as a .rag file named after the directory. You can see what you’ve got with M-x ollama-buddy-rag-list-indexes.

The chunking strategy

One thing I’m quite happy with here is the chunking. Rather than just splitting on a fixed character count, documents are split into overlapping word-based chunks. The defaults are:

(setq ollama-buddy-rag-chunk-size 400) ; ~500 tokens per chunk
(setq ollama-buddy-rag-chunk-overlap 50) ; 50-word overlap between chunks

The overlap is important - it means a piece of information that sits right at a chunk boundary doesn’t get lost. Each chunk also tracks its source file and line numbers, so you can see exactly where a result came from.

Searching and attaching context

Once you have an index, there are two main ways to use it:

M-x ollama-buddy-rag-search - searches and displays the results in a dedicated buffer so you can read through them
M-x ollama-buddy-rag-attach - searches and attaches the results directly to your chat context

The second one is the useful one for day-to-day work. After running it, your next chat message will automatically include the retrieved document chunks as context. The status line shows ♁N (where N is the number of attached searches) so you always know what context is in play. Clear everything with M-x ollama-buddy-clear-attachments or C-c 0.

You can also trigger searches inline using the @rag() syntax directly in your prompt and is something fun I have been working on to include an inline command language of sorts, but more about that in a future post.

The similarity search uses cosine similarity with sensible defaults (hopefully!)

(setq ollama-buddy-rag-top-k 5) ; return top 5 matching chunks
(setq ollama-buddy-rag-similarity-threshold 0.3) ; filter out low-relevance results

Bump top-k if you want more context, lower the threshold if you’re not getting enough results.

A practical example

Say you’ve been working on a large Emacs package and you want the LLM to help you understand something specific. You’d do:

M-x ollama-buddy-rag-index-directory → point at your project directory
Wait for indexing to complete (the chat header-line shows progress)
M-x ollama-buddy-rag-attach → type your search query, e.g. “streaming filter process”
Ask your question in the chat buffer as normal

The LLM now has the relevant source chunks as context and can give you a much more grounded answer than it would cold.

And the important aspect, especially regarding local models which don’t often have the huge context sizes often found in online LLMs is that it allows for very efficient context retrieval.

That’s pretty much it!

The whole thing is self-contained inside Emacs, no external packages or vector databases, you index once, search as needed, and the LLM gets actual information rather than hallucinating answers about your codebase or anything else that you would want to ingest and it will hopefully make working with local LLMs through ollama noticeably more useful and accurate.

Ollama Buddy v2.0 - LLMs can now call Emacs functions!

James Dyer — Mon, 16 Feb 2026 08:56:00 +0000

Tool calling has landed in ollama-buddy!, it’s originally not something I really thought I would end up doing, but as ollama has provided tool enabled models and an API for this feature then I felt obliged to add it. So now LLMs through ollama can now actually do things inside Emacs rather than just talk about them, my original “do things only in the chat buffer and copy and paste” might have gone right out the window in an effort to fully support the ollama API!

What is Tool Calling?

The basic idea is simple: instead of the model only generating text, it can request to invoke functions. You ask “what files are in my project?”, and instead of guessing, the model calls list_directory, gets the real answer, and responds with actual information.

This creates a conversational loop:

You send a prompt
The model decides it needs to call a tool
ollama-buddy executes the tool and feeds the result back
The model generates a response using the real data
Steps 2-4 repeat if more tools are needed

All of this is transparent - you just see the final response in the chat buffer.

The new ollama-buddy-tools.el module ships with 8 built-in tools:

Safe tools (read-only, enabled by default):

read_file - read file contents
list_directory - list directory contents
get_buffer_content - read an Emacs buffer
list_buffers - list open buffers with optional regex filtering
search_buffer - regex search within a buffer
calculate - evaluate math expressions via calc-eval

Unsafe tools (require safe mode off):

write_file - write content to files
execute_shell - run shell commands

Safe mode is on by default, so the model can only read - it can’t modify anything unless you explicitly allow it, I think this is quite a nice simple implementation, at the moment I generally have safe mode off but always allowing confirmation for each tool action, but of course you can configure as necessary.

Example Session

With a tool-capable model like qwen3:8b and tools enabled (C-c W):

>> PROMPT: What defuns are defined in ollama-buddy-tools.el?

The model calls search_buffer with a regex pattern, gets the list of function definitions, and gives you a nicely formatted summary. No copy-pasting needed.

Custom Tools

You can register your own tools with ollama-buddy-tools-register:

 (ollama-buddy-tools-register
'my-tool
"Description of what the tool does"
'((type . "object")
(required . ["param1"])
(properties . ((param1 . ((type . "string")
(description . "Parameter description"))))))
(lambda (args)
(let ((param1 (alist-get 'param1 args)))
(format "Result: %s" param1)))
t) ; t = safe tool

The registration API takes a name, description, JSON schema for parameters, an implementation function, and a safety flag. The model sees the schema and decides when to call your tool based on the conversation.

A ⚒ symbol now appears next to tool-capable models everywhere - header line, model selector (C-c m), and model management buffer (C-c M). This follows the same pattern as the existing ⊙ vision indicator, so you can see at a glance which models support tools.

That’s it. Pull a tool-capable model (qwen3, llama3.1, mistral, etc.) or use an online tool enabled model from ollama and start chatting. Next up is probably some web searching!, as again the ollama API supports this, so you will be able to pull in the latest from the interwebs to augment your prompt definition!

Spent a bit of free time polishing ollama-buddy - github Copilot is now onboard!

James Dyer — Wed, 04 Feb 2026 10:40:00 +0000

I’ve had a little free time recently (figuring out this baby stuff!) and thought I would spend time revisiting and refining my AI assistant ollama-buddy

I’ve been playing around with agentic coding and keeping up-to-date on the rapid development of the Emacs AI package landscape and I think I have refined in my own mind my idea of what I would like to see in an Emacs AI assistant.

The headline change regarding the latest release of ollama-buddy is GitHub Copilot integration; the rest of the work is about smoothing the UI and simplifying day-to-day use.

What’s new - the Copilot addition (v1.2)

GitHub Copilot Chat API support via a new file, ollama-buddy-copilot.el, so Copilot models can be used alongside your existing providers.
Authentication uses GitHub’s device flow (OAuth). No API key required: M-x ollama-buddy-copilot-login opens a browser and guides you through secure authentication.
Copilot models are identified with a “p:” prefix (for example, p:gpt-4o). The header line shows a “p” indicator when the Copilot provider is loaded so you always know it’s available.
Copilot access exposes a broad set of models from multiple vendors through the Copilot interface: OpenAI (gpt-4o, gpt-5), Anthropic (claude-sonnet-4, claude-opus-4.5), Google (gemini-2.5-pro), and xAI models.
Quick usage notes:
1. Ensure you have an active GitHub Copilot subscription.
2. Run M-x ollama-buddy-copilot-login.
3. Enter the device code in your browser at github.com/login/device when prompted.
4. Select a Copilot model with C-c m (e.g., p:gpt-4o).
Example config to load Copilot support:

(use-package ollama-buddy
:bind
("C-c o" . ollama-buddy-menu)
("C-c O" . ollama-buddy-transient-menu-wrapper)
:config
(require 'ollama-buddy-copilot nil t))

Other notable updates in this release series

v1.2.1 (2026-02-02)
- Attachment count indicator on the header line so you get a constant visual reminder that the session has attachments.
v1.1.5 (2026-01-31)
- Global system prompt feature (enabled by default): sets a baseline set of instructions (for example, to prefer plain prose and avoid markdown tables) that is prepended to session-specific system prompts. This helps keep responses consistent across providers and things like malformed markdown tables for example, which seems to be common. There’s a toggle (ollama-buddy-global-system-prompt-enabled) and a quick command to flip it (ollama-buddy-toggle-global-system-prompt), plus a transient-menu entry.
- Consolidated model management: streamlined into a single model management buffer (C-c W) and the welcome screen now points to that buffer for model tasks.
v1.1.4 (2026-01-31)
- Header-line and keybinding cleanup: C-c RET to send prompts (matches gptel, as I feel this seems intuitive), removed a redundant backend indicator, shortened the markdown indicator to “MD”, and fixed markdown → org heading conversion to keep structure sane.
v1.1.3 (2026-01-31)
- Chat UX improvements and simplification: added ollama-buddy-auto-scroll (default nil — don’t auto-scroll so you can read while streaming) and ollama-buddy-pulse-response (flashes the response on completion, taking from gptel again, as if there is no autoscrolling it is useful to visually see when the response has completed). Removed the model name coloring feature and related toggles to simplify code and improve org-mode performance.
v1.1.2 (2026-01-30)
- Streamlined welcome screen and model selection, clearer provider indicators in the header line and an improved list of enabled online LLM providers.

Ollama buddy now supports cloud models!

James Dyer — Wed, 28 Jan 2026 08:29:00 +0000

Having another look at my AI assistant - ollama-buddy, its been a while and it seems ollama has moved on since I started creating this package last year, so I have developed a new roadmap and the first step is to add ollama cloud models!

Here are some references to the project, including a youtube channel where I upload ollama-buddy demonstrations:

https://melpa.org/#/ollama-buddy

https://github.com/captainflasmr/ollama-buddy

Here is the changelog for the cloud model implementation:

<2026-01-28 Wed> 1.1

Added Ollama Cloud Models support

Cloud models (running on ollama.com infrastructure) now work seamlessly
ollama-buddy-cloud-signin to automatically open browser for authentication
Cloud models are proxied through the local Ollama server which handles authentication
Use C-u C-c m or transient menu “Model > Cloud” to select cloud models
Status line shows ☁ indicator when using a cloud model
Available cloud models include: qwen3-coder:480b-cloud, deepseek-v3.1:671b-cloud, gpt-oss:120b-cloud, minimax-m2.1:cloud, and more

Expanding Ollama Buddy: Mistral Codestral Integration

James Dyer — Thu, 11 Dec 2025 08:19:00 +0000

Ollama Buddy now supports Mistral’s Codestral - a powerful code-generation model from Mistral AI that seamlessly integrates into the ollama-buddy ecosystem.

https://github.com/captainflasmr/ollama-buddy

https://melpa.org/#/ollama-buddy

So now we have:

Local Ollama models — full control, complete privacy
OpenAI — extensive model options and API maturity
Claude — reasoning and complex analysis
Gemini — multimodal capabilities
Grok — advanced reasoning models
Codestral — specialized code generation NEW

To get up and running…

First, sign up at Mistral AI and generate an API key from your dashboard.

Add this to your Emacs configuration:

(use-package ollama-buddy
 :bind
 ("C-c o" . ollama-buddy-menu)
 ("C-c O" . ollama-buddy-transient-menu-wrapper)
 :custom
 (ollama-buddy-codestral-api-key
 (auth-source-pick-first-password :host "ollama-buddy-codestral" :user "apikey"))
 :config
 (require 'ollama-buddy-codestral nil t))

Once configured, Codestral models will appear in your model list with an s: prefix (e.g., s:codestral-latest). You can:

Select it from the model menu (C-c m)
Use it with any command that supports model selection
Switch between local and cloud models on-the-fly

Ollama Buddy v1.0: A Simple AI Assistant

James Dyer — Wed, 23 Jul 2025 09:20:00 +0100

After months of development and refinement, I’m excited to announce Ollama Buddy v1.0 - an Emacs package that simply interfaces mainly to ollama, for local LLM usage, but can be integrated to the major online players. This project initially started as a simple integration with Ollama and since then has somewhat evolved into a more fully fully-featured AI Emacs assistant. The main focus with this package is a front facing simplicity but hiding (hopefully) all the features you would expect from an AI chatbot - wait I hate that term, I mean, assistant :). There is also the ability to craft a customizable menu system for different roles.

I had a blast developing this package and next up is RAG!. I saw recently that a package called vecdb was introduced into the package ecosystem to help with the storage of vector embeddings, so as ollama can return embedding vectors for semantic search I thought I would combine my package, vecdb, also probably initially a PostgreSQL database with a pgvector extension and ollama into something that could ingest files directly from Emacs. I think I have figured this out now, I just need to do it (when the baby is asleep, probably!)

Why Choose Ollama Buddy?

I designed Ollama Buddy to be as simple as possible to set up, no backend configuration or complex setup required. This was achievable initially because I focused solely on Ollama integration, where models are automatically discoverable.

Since then, I’ve expanded support to major online AI providers while maintaining that same simplicity through a modular architecture. The system now handles multiple providers without adding complexity to the user experience.

Another key feature is the customizable menu system, which integrates with role-based switching. You can create specialized AI menus for different contexts, like a coding-focused setup or a writing-optimized configuration and switch between them instantly. Everything is fully configurable to match your workflow.

Links

Here are some links:

https://github.com/captainflasmr/ollama-buddy https://melpa.org/#/ollama-buddy

I will outline the major features below, but I do have a manual available!

https://github.com/captainflasmr/ollama-buddy/blob/main/docs/ollama-buddy.org

Key Features

Multiple AI Providers

Local Models: Full support for Ollama with automatic model management
Cloud Services: Integrated support for OpenAI (ChatGPT), Anthropic Claude, Google Gemini, and Grok
Seamless Switching: Change between local and cloud models with a single command
Unified Interface: Same commands work across all providers

Preset Roles: Switch between different AI personalities (developer, writer, analyst, etc.)
Custom Roles: Create specialized workflows with specific models and parameters
Menu Customization: Each role can have its own set of commands and shortcuts

Chat Interface

Org-mode Integration: Conversations rendered in structured org-mode format
Real-time Streaming: Watch responses appear token by token
Context Management: Visual context window monitoring with usage warnings
History Tracking: Full conversation history with model-specific storage

File Handling

File Attachments: Attach documents directly to conversations for context-aware analysis
Vision Support: Upload and analyse images with vision-capable models
Dired Integration: Bulk attach files directly from Emacs file manager

Prompt Management

System Prompts: Create and manage reusable system prompts for different use cases
Fabric Integration: Auto-sync with Fabric patterns (200+ professional prompts)
Awesome ChatGPT Prompts: Built-in access to the popular prompt collection
User Prompts: Create and organize your own custom prompt library (which of course is org based)

Session Management

Save & Restore: Full session persistence including history, attachments, and settings
Session Browser: Visual interface to manage multiple conversation sessions
Auto-naming: Intelligent session naming based on conversation content

Flexible Interface Options

Two Interface Levels: Basic mode for beginners, advanced for power users
Transient Menus: Magit-style discoverable command interface
Custom Menus: Traditional text-based menu system
Keyboard Shortcuts: Comprehensive keybinding system for efficiency, I’m not sure there are any keys left!!

What’s Next?

Version 1.0 represents a stable, foundation, Ollama Buddy has been out there now for a few months with only a single github issue but development continues with:

RAG integration using perhaps the new vecdb package, as mentioned above
Additional AI provider integrations (Perplexity maybe?, any suggestions?)
Auto-completion (not sure how doable this is with ollama, but I do have a prototype)

Ollama Buddy 0.12.0: User Prompt Library, File Attachments, Vision and Context Tracking

James Dyer — Fri, 23 May 2025 14:10:00 +0100

There have been quite a few updates recently. The main highlights include support for attachments, so you can push a file to the chat directly from dired for potential inclusion in your next query.

Vision support has been added for models that can handle it. If you supply the path to an image file in the chat, it will be processed. This means you can now, for example, extract text from images using models like o:gemma3:4b.

I’ve also introduced the ability to save user system prompts. If you have a favorite prompt, or have crafted one that works especially well for you, you can now save it by category and title in a simple Org format for later recall. Prompt recall now works the same way as Fabric patterns and Awesome ChatGPT prompts. This makes it much easier to display the currently used system prompt concisely in the status bar, as it will be based on the prompt title (and thus likely the role).

What else? Oh yes, I received a request for better context tracking. Now, when context is nearing full capacity, or has exceeded it, it will be indicated in the status bar!

That’s probably it for the major changes. There was also some refactoring, but you probably don’t care about that. Anyway, here is the full list of changes:

<2025-05-22 Thu> 0.12.0

Full system prompt in the status bar replaced with a more meaningful simple role title

Added system prompt metadata tracking with title, source, and timestamp registry
Implemented automatic title extraction and unified completing-read interface
Enhanced fabric/awesome prompt integration with proper metadata handling
Improved transient menu organization and org-mode formatting with folding
Added system prompt history display and better error handling for empty files
Transient menu has been simplified and reorganised

Previously, the header status bar would show truncated system prompt text like [You are a helpful assistant wh...], making it difficult to quickly identify which prompt was active. Now, the display shows meaningful role titles with source indicators:

[F:Code Reviewer] - Fabric pattern
[A:Linux Terminal] - Awesome ChatGPT prompt
[U:Writing Assistant] - User-defined prompt

The system now intelligently extracts titles from prompt content by recognizing common patterns like “You are a…”, “Act as…”, or “I want you to act as…”. When these patterns aren’t found, it generates a concise title from the first few words.

Behind the scenes, Ollama Buddy now maintains a registry of all system prompts with their titles, sources, and timestamps. This enables new features like system prompt history viewing and better organization across Fabric patterns, Awesome ChatGPT prompts, and user-defined prompts.

The result is a cleaner interface that makes it immediately clear which role your AI assistant is currently embodying, without cluttering the status bar with long, truncated text.

<2025-05-21 Wed> 0.11.1

Quite a bit of refactoring to generally make this project more maintainable and I have added a starter kit of user prompts.

Color System Reworking
- Removed all model color-related functions and variables
- Removed dependency on color.el
- Replaced with highlight-regexp and hashing to ^font-lock faces, so now using a more native built-in solutions for model colouring rather than shoe-horning in overlays.
UI Improvements
- Simplified the display system by leveraging Org mode
- Added org-mode styling for output buffers
- Added org-hide-emphasis-markers and org-hide-leading-stars settings
- Changed formatting to use Org markup instead of text properties
- Converted plain text headers to proper Org headings
- Replaced color properties with Org emphasis (bold)
History Management Updates
- Streamlined history editing functionality
- Improved model-specific history editing
- Refactored history display and navigation
System Prompts
- Added library of system prompts in these categories:
  - analysis (3 prompts)
  - coding (5 prompts)
  - creative (3 prompts)
  - documentation (3 prompts)
  - emacs (10 prompts)
  - general (3 prompts)
  - technical (3 prompts)
  - writing (3 prompts)

<2025-05-19 Mon> 0.11.0

Added user system prompts management

You can now save, load and manage system prompts
Created new transient menu for user system prompts (C-c s)
Organized prompts by categories with org-mode format storage
Supported prompt editing, listing, creation and deletion
Updated key bindings to integrate with existing functionality
Added prompts directory customization with defaults

This feature makes it easier to save, organize, and reuse your favorite system prompts when working with Ollama language models.

System prompts are special instructions that guide the behavior of language models. By setting effective system prompts, you can:

Define the AI’s role (e.g., “You are a helpful programming assistant who explains code clearly”)
Establish response formats
Set the tone and style of responses
Provide background knowledge for specific domains

The new ollama-buddy-user-prompts module organizes your system prompts in a clean, category-based system:

Save your prompts - Store effective system prompts you’ve crafted for future use
Categorize - Prompts are organized by domains like “coding,” “writing,” “technical,” etc.
Quick access - Browse and load your prompt library with completion-based selection
Edit in org-mode - All prompts are stored as org files with proper metadata
Manage with ease - Create, edit, list, and delete prompts through a dedicated transient menu

The new functionality is accessible through the updated key binding C-c s, which opens a dedicated transient menu with these options:

Save current (S) - Save your active system prompt
Load prompt (L) - Choose a previously saved prompt
Create new (N) - Start fresh with a new prompt
List all Prompts (l) - View your entire prompt library
Edit prompt (e) - Modify an existing prompt
Delete prompt (d) - Remove prompts you no longer need

If you work frequently with Ollama models, you’ve likely discovered the power of well-crafted system prompts. They can dramatically improve the quality and consistency of responses. With this new management system, you can:

Build a personal library of effective prompts
Maintain context continuity across sessions
Share prompts with teammates
Refine your prompts over time

<2025-05-14 Wed> 0.10.0

Added file attachment system for including documents in conversations

Added file attachment support with configurable file size limits (10MB default) and supported file types
Implemented session persistence for attachments in save/load functionality
Added attachment context inclusion in prompts with proper token counting
Created comprehensive attachment management commands:
- Attach files to conversations
- Show current attachments in dedicated buffer
- Detach specific files
- Clear all attachments
Added Dired integration for bulk file attachment
Included attachment menu in transient interface (C-c 1)
Updated help text to document new attachment keybindings
Enhanced context calculation to include attachment token usage

You can now seamlessly include text files, code, documentation, and more directly in your conversations with local AI models!

Simply use C-c C-a from the chat buffer to attach any file to your current conversation.

The attached files become part of your conversation context, allowing the AI to reference, analyze, or work with their contents directly.

The transient menu has also been updated with a new Attachment Menu

*File Attachments*
a Attach file
w Show attachments
d Detach file
0 Clear all attachments

Your attachments aren’t just dumped into the conversation - they’re intelligently integrated:

Token counting now includes attachment content, so you always know how much context you’re using
Session persistence means your attachments are saved and restored when you save/load conversations
File size limits (configurable, 10MB default) prevent accidentally overwhelming your context window

Managing attached files is intuitive with dedicated commands:

C-c C-w - View all current attachments in a nicely formatted org mode buffer, folded to each file
C-c C-d - Detach specific files when you no longer need them
C-c 0 - Clear all attachments at once
C-c 1 - Access the full attachment menu via a transient interface

Working in Dired? No problem! You can attach files directly from your file browser:

Mark multiple files and attach them all at once
Attach the file at point with a single command

Use the configuration as follows:

(eval-after-load 'dired
 '(progn
 (define-key dired-mode-map (kbd "C-c C-a") #'ollama-buddy-dired-attach-marked-files)))

<2025-05-12 Mon> 0.9.50

Added context size management and monitoring

Added configurable context sizes for popular models (llama3.2, mistral, qwen, etc.)
Implemented real-time context usage display in status bar
Can display in text or bar display types
Added context size thresholds with visual warnings
Added interactive commands for context management:
- ollama-buddy-show-context-info: View all model context sizes
- ollama-buddy-set-model-context-size: Manually configure model context
- ollama-buddy-toggle-context-percentage: Toggle context display
Implemented context size validation before sending prompts
Added token estimation and breakdown (history/system/current prompt)
Added keybindings: C-c $ (set context), C-c % (toggle display), C-c C (show info)
Updated status bar to show current/max context with fontification

I’ve added context window management and monitoring capabilities to Ollama Buddy!

This update helps you better understand and manage your model’s context usage, preventing errors and optimizing your conversations.

Enable it with the following:

(setq ollama-buddy-show-context-percentage t)

Usage

After implementing these changes:

Text mode: Shows 1024/4096 style display
Bar mode (default): Shows ███████░░░░ 2048 style display
Use C-c 8 to toggle between modes
The Text mode will change fontification based on your thresholds:
- Normal: regular fontification
- (85%+): underlined and bold
- (100%+): inverse video and bold
The Bar mode will just fill up as normal

The progress bar will visually represent how much of the context window you’re using, making it easier to see at a glance when you’re approaching the limit.

Implementation Details

Context Size Detection

Determining a model’s context size proved more complex than expected. While experimenting with parsing model info JSON, I discovered that context size information can be scattered across different fields. Rather than implementing a complex JSON parser (which may come later), I chose a pragmatic approach:

I created a new defcustom variable ollama-buddy-fallback-context-sizes that includes hard-coded values for popular Ollama models. The fallback mechanism is deliberately simple: substring matching followed by a sensible default of 4096 tokens.

(defcustom ollama-buddy-fallback-context-sizes
 '(("llama3.2:1b" . 2048)
 ("llama3:8b" . 4096)
 ("tinyllama" . 2048)
 ("phi3:3.8b" . 4096)
 ("gemma3:1b" . 4096)
 ("gemma3:4b" . 8192)
 ("llama3.2:3b" . 8192)
 ("llama3.2:8b" . 8192)
 ("llama3.2:70b" . 8192)
 ("starcoder2:3b" . 8192)
 ("starcoder2:7b" . 8192)
 ("starcoder2:15b" . 8192)
 ("mistral:7b" . 8192)
 ("mistral:8x7b" . 32768)
 ("codellama:7b" . 8192)
 ("codellama:13b" . 8192)
 ("codellama:34b" . 8192)
 ("qwen2.5-coder:7b" . 8192)
 ("qwen2.5-coder:3b" . 8192)
 ("qwen3:0.6b" . 4096)
 ("qwen3:1.7b" . 8192)
 ("qwen3:4b" . 8192)
 ("qwen3:8b" . 8192)
 ("deepseek-r1:7b" . 8192)
 ("deepseek-r1:1.5b" . 4096))
 "Mapping of model names to their default context sizes.
Used as a fallback when context size can't be determined from the API."
 :type '(alist :key-type string :value-type integer)
 :group 'ollama-buddy)

This approach may not be perfectly accurate for all models, but it’s sufficient for getting the core functionality working. More importantly, as a defcustom, users can easily customize these values for complete accuracy with their specific models. Users can also set context values within the chat buffer through C-c C (Show Context Information) for each individual model if desired.

This design choice allowed me to focus on the essential features without getting stuck on complex context retrieval logic.

One final thing!, if the num_ctx: Context window size in tokens is set, then that number will also be taken into consideration. An assumption will be made that the model is honouring the context size requested and will incorporated into the context calculations accordingly.

Token Estimation

For token counting, I’ve implemented a simple heuristic: each word (using string-split) is multiplied by 1.3. This follows commonly recommended approximations and works well enough in practice. While this isn’t currently configurable, I may add it as a customization option in the future.

How to Use Context Management in Practice

The C-c C (Show Context Information) command is central to this feature. Rather than continuously monitoring context size while you type (which would be computationally expensive and potentially distracting), I’ve designed the system to calculate context on-demand when you choose.

Typical Workflows

Scenario 1: Paste-and-Send Approach

Let’s say you want to paste a large block of text into the chat buffer. You can simply:

Paste your content
Press the send keybinding
If the context limit is exceeded, you’ll get a warning dialog asking whether to proceed anyway

Scenario 2: Preemptive Checking

For more control, you can check context usage before sending:

Paste your content
Run C-c C to see the current context breakdown
If the context looks too high, you have several options:
- Trim your current prompt
- Remove or simplify your system prompt
- Edit conversation history using Ollama Buddy’s history modification features
- Switch to a model with a larger context window

Scenario 3: Manage the Max History Length

Want tight control over context size without constantly monitoring the real-time display? Since conversation history is part of the context, you can simply limit ollama-buddy-max-history-length to control the total context size.

For example, when working with small context windows, set ollama-buddy-max-history-length to 1. This keeps only the last exchange (your prompt + model response), ensuring your context remains small and predictable, perfect for maintaining control without manual monitoring.

Scenario 4: Parameter num_ctx: Context window size in tokens

Simply set this parameter and off you go!

Current Status: Experimental

Given the potentially limiting nature of context management, I’ve set this feature to disabled by default.

But to enable set the following :

(setq ollama-buddy-show-context-percentage t)

This means:

Context checks won’t prevent sending prompts
Context usage won’t appear in the status line
However, calculations still run in the background, so C-c C (Show Context Information) remains functional

As the feature matures and proves its value, I may enable it by default. For now, consider it an experimental addition that users can opt into.

More Details

The status bar now displays your current context usage in real-time. You’ll see a fraction showing used tokens versus the model’s maximum context size (e.g., “2048/8192”). The display automatically updates as your conversation grows.

Context usage changes fontification to help you stay within limits:

Normal font: Normal usage (under 85%)
Bold and Underlined: Approaching limit (85-100%)
Inversed: At or exceeding limit (100%+)

Before sending prompts that exceed the context limit, Ollama Buddy now warns you and asks for confirmation. This prevents unexpected errors and helps you manage long conversations more effectively.

There are now three new interactive commands:

C-c $ - Set Model Context Size. Manually configure context sizes for custom or fine-tuned models.

C-c % - Toggle Context Display. Show or hide the context percentage in the status bar.

C-c C - Show Context Information. View a detailed breakdown of:

All model context sizes
Current token usage by category (history, system prompt, current prompt)
Percentage usage

The system estimates token counts for:

Conversation history: All previous messages
System prompts: Your custom instructions
Current input: The message you’re about to send

This gives you a complete picture of your context usage before hitting send.

The context monitoring is not enabled by default.

<2025-05-05 Mon> 0.9.44

Sorted model names alphabetically in intro message
Removed multishot writing to register name letters

For some reason, when I moved the .ollama folder to an external disk, the models returned with api/tags were inconsistent, which meant it broke consistent letter assignment. I’m not sure why this happened, but it is probably sensible to sort the models alphabetically anyway, as this has the benefit of naturally grouping together model families.

I also removed the multishot feature of writing to the associated model letter. Now that I have to accommodate more than 26 models, incorporating them into the single-letter Emacs register system is all but impossible. I suspect this feature was not much used, and if you think about it, it wouldn’t have worked anyway with multiple model shots, as the register letter associated with the model would just show the most recent response. Due to these factors, I think I should remove this feature. If someone wants it back, I will probably have to design a bespoke version fully incorporated into the ollama-buddy system, as I can’t think of any other Emacs mechanism that could accommodate this.

<2025-05-05 Mon> 0.9.43

Fix model reference error exceeding 26 models #15

Update ollama-buddy to handle more than 26 models by using prefixed combinations for model references beyond ‘z’. This prevents errors in create-intro-message when the local server hosts a large number of models.

<2025-05-03 Sat> 0.9.42

Added the following to recommended models:

qwen3:0.6b
qwen3:1.7b
qwen3:4b
qwen3:8b

and fixed pull model

<2025-05-02 Fri> 0.9.41

Refactored model prefixing again so that when using only ollama models no prefix is applied and is only applied when online LLMs are selected (for example claude, chatGPT e.t.c)

I think this makes more sense and is cleaner for I suspect the majority who may use this package are probably more interested in just using ollama models and the prefix will probably be a bit confusing.

This could be a bit of a breaking change once again I’m afraid for those ollama users that have switched and are now familiar with prefixing “o:”, sorry!

<2025-05-02 Fri> 0.9.40

Added vision support for those ollama models that can support it!

Image files are now detected within a prompt and then processed if a model can support vision processing. Here’s a quick overview of how it works:

Configuration: Users can configure the application to enable vision support and specify which models and image formats are supported. Vision support is enabled by default.
Image Detection: When a prompt is submitted, the system automatically detects any image files referenced in the prompt.
Vision Processing: If the model supports vision, the detected images are processed in relation to the defined prompt. Note that the detection of a model being vision capable is defined in ollama-buddy-vision-models and can be adjusted as required.
In addition, a menu item has been added to the custom ollama buddy menu :
```
 [I] Analyze an Image
```

When selected, it will allow you to describe a chosen image. At some stage, I may allow integration into dired, which would be pretty neat. :)

Ollama-Buddy 0.9.38: Unload Models, Hide AI Reasoning, and Clearly View Modified Parameters on each request

James Dyer — Thu, 01 May 2025 13:33:00 +0100

More improvements to ollama-buddy https://github.com/captainflasmr/ollama-buddy

<2025-04-29 Tue> 0.9.38

Added model unloading functionality to free system resources

Add unload capability for individual models via the model management UI
Create keyboard shortcut (C-c C-u) for quick unloading of all models
Display running model count and unload buttons in model management buffer

Large language models consume significant RAM and GPU memory while loaded. Until now, there wasn’t an easy way to reclaim these resources without restarting the Ollama server entirely. This new functionality allows you to:

Free up GPU memory when you’re done with your LLM sessions
Switch between resource-intensive tasks more fluidly
Manage multiple models more efficiently on machines with limited resources
Avoid having to restart the Ollama server just to clear memory

There are several ways to unload models with the new functionality:

Unload All Models: Press C-c C-u to unload all running models at once (with confirmation)
Model Management Interface: Access the model management interface with C-c W where you’ll find:
- A counter showing how many models are currently running
- An “Unload All” button to free all models at once
- Individual “Unload” buttons next to each running model
Quick Access in Management Buffer: When in the model management buffer, simply press u to unload all models

The unloading happens asynchronously in the background, with clear status indicators so you can see when the operation completes.

<2025-04-25 Fri> 0.9.37

Display modified parameters in token stats

Enhanced the token statistics section to include any modified parameters, providing a clearer insight into the active configurations. This update helps in debugging and understanding the runtime environment.

<2025-04-25 Fri> 0.9.36

Added Reasoning/Thinking section visibility toggle functionality

Introduced the ability to hide reasoning/thinking sections during AI responses, making the chat output cleaner and more focused on final results
Added a new customizable variable ollama-buddy-hide-reasoning (default: nil) which controls visibility of reasoning sections
Added ollama-buddy-reasoning-markers to configure marker pairs that encapsulate reasoning sections (supports multiple formats like <think></think> or —-)
Added ollama-buddy-toggle-reasoning-visibility interactive command to switch visibility on/off
Added keybinding C-c V for toggling reasoning visibility in chat buffer
Added transient menu option “V” for toggling reasoning visibility
When reasoning is hidden, a status message shows which section is being processed (e.g., “Think…” or custom marker names)
Reasoning sections are automatically detected during streaming responses
Header line now indicates when reasoning is hidden with “REASONING HIDDEN” text
All changes preserve streaming response functionality while providing cleaner output

This feature is particularly useful when working with AI models that output their “chain of thought” or reasoning process before providing the final answer, allowing users to focus on the end results while still having the option to see the full reasoning when needed.

Ollama-Buddy 0.9.35: Grok, Gemini Integration and Enhanced Sessions

James Dyer — Thu, 24 Apr 2025 09:20:00 +0100

Several improvements in the latest Ollama Buddy updates (versions 0.9.21 through 0.9.35):

🎉 New AI Integrations with Grok and Gemini

Google’s Gemini is now complementing existing support for Claude, ChatGPT (OpenAI), and Ollama models. Setting up is straightforward and consistent with other integrations.
Just like the existing integrations, Grok can now be easily configured with your API key.

🔗 Improved Remote LLM Architecture

LLM internal decoupling, making Ollama Buddy’s core logic independent from any specific remote LLM. Each LLM integration now functions as a self-contained extension, significantly simplifying future additions and maintenance.

🎯 Standardized Model Prefixing

Now there are more remote LLMs into the mix I thought it was probably time to more clearly distinguish between model collections, so I have defined the following prefixes:

Ollama: o:
ChatGPT: a:
Claude: c:
Gemini: g:
Grok: k:

This change helps ensure clarity, especially when recalling previous sessions. Note: existing session files will need the Ollama prefix (o:) added manually if you encounter issues recalling older sessions.

💾 Enhanced Session Management

Saving session now makes a little more sense and is more consistent:

Automatic timestamped session names (you can still set your own).
Sessions now also save as org files alongside the original elisp files, allowing for richer recall and easy inspection later.
The current session name appears dynamically in your modeline, offering quick context.

🛠️ Additional Improvements

UTF-8 encoding fixes for remote LLM stream responses.
Refactored history and model management so all the latest models are available for selection. This is currently most relevant for remote LLMs which often change their model selection.
History view/edit functionality merged into one keybinding

and here is the change history

<2025-04-21 Mon> 0.9.35

Added Grok support

Integration is very similar to other remote AIs:

(use-package ollama-buddy
 :bind
 ("C-c o" . ollama-buddy-menu)
 ("C-c O" . ollama-buddy-transient-menu-wrapper)
 :custom
 (ollama-buddy-grok-api-key
 (auth-source-pick-first-password :host "ollama-buddy-grok" :user "apikey"))
 :config
 (require 'ollama-buddy-grok nil t))

<2025-04-20 Sun> 0.9.33

Fixed utf-8 encoding stream response issues from remote LLMs.

<2025-04-19 Sat> 0.9.32

Finished the remote LLM decoupling process, meaning that the core ollama-buddy logic is now not dependent on any remote LLM, and each remote LLM package is self-contained and functions as a unique extension.

<2025-04-18 Fri> 0.9.31

Refactored model prefixing logic and cleaned up

Standardized model prefixing by introducing distinct prefixes for Ollama (o:), OpenAI (a:), Claude (c:), and Gemini (g:) models.
Centralized functions to get full model names with prefixes across different model types.
Removed redundant and unused variables related to model management.

Note that there may be some breaking changes here especially regarding session recall as all models will now have a prefix to uniquely identify their type. For ollama recall, just edit the session files to prepend the ollama prefix of “o:”

<2025-04-17 Thu> 0.9.30

Added Gemini integration!

As with the Claude and ChatGPT integration, you will need to add something similar to them in your configuration. I currently have the following set up to enable access to the remote LLMs:

(use-package ollama-buddy
 :bind
 ("C-c o" . ollama-buddy-menu)
 ("C-c O" . ollama-buddy-transient-menu-wrapper)
 :custom
 (ollama-buddy-openai-api-key
 (auth-source-pick-first-password :host "ollama-buddy-openai" :user "apikey"))
 (ollama-buddy-claude-api-key
 (auth-source-pick-first-password :host "ollama-buddy-claude" :user "apikey"))
 (ollama-buddy-gemini-api-key
 (auth-source-pick-first-password :host "ollama-buddy-gemini" :user "apikey"))
 :config
 (require 'ollama-buddy-openai nil t)
 (require 'ollama-buddy-claude nil t)
 (require 'ollama-buddy-gemini nil t))

Also with the previous update all the latest model names will be pulled, so there should be a full comprehensive list for each of the main remote AI LLMs!

<2025-04-16 Wed> 0.9.23

Refactored history and model management for remote LLMs

Now pulling in latest model list for remote LLMs (so now ChatGPT 4.1 is available!)
Removed redundant history and model management functions from ollama-buddy-claude.el and ollama-buddy-openai.el. Replaced them with shared implementations to streamline code and reduce duplication

<2025-04-15 Tue> 0.9.22

Enhanced session management

Refactored ollama-buddy-sessions-save to autogenerate session names using timestamp and model.
Improved session saving/loading by integrating org file handling.
Updated mode line to display current session name dynamically.

Several improvements to session management, making it more intuitive and efficient for users. Here’s a breakdown of the new functionality:

When saving a session, Ollama Buddy now creates a default name using the current timestamp and model name, users can still provide a custom name if desired.

An org file is now saved alongside the original elisp session file. This allows for better session recall as all interactions will be pulled back with the underlying session parameters still restored as before. There is an additional benefit in not only recalling precisely the session and any additional org interactions but also quickly saving to an org file for potential later inspection. Along with the improved autogenerated session name, this means it is much faster and more intuitive to save a snapshot of the current chat interaction.

The modeline now displays the current session name!

<2025-04-11 Fri> 0.9.21

Add history edit/view toggle features, so effectively merging the former history display into the history edit functionality.

Ollama-Buddy 0.9.20: Curated AI Prompting with Awesome ChatGPT Prompts

James Dyer — Wed, 09 Apr 2025 13:43:00 +0100

Added ollama-buddy-awesome.el to integrate Awesome ChatGPT Prompts.

ollama-buddy-awesome is an ollama-buddy extension that integrates the popular Awesome ChatGPT Prompts repository, allowing you to leverage hundreds of curated prompts for various tasks and roles right within your Emacs environment, I thought that since I have integrated the fabric set of curated prompts, so then why not these!

There is a video demonstration here : https://www.youtube.com/watch?v=5A4bTvjmPeo

Key Features

Seamless Sync: Automatically fetch the latest prompts from the GitHub repository, ensuring you always have access to the most up-to-date collection.
Smart Categorization: Prompts are intelligently categorized based on their content, making it easy to find the perfect prompt for your task.
Interactive Selection: Choose prompts through Emacs’ familiar completion interface, with category and title information for quick identification.
Effortless Application: Apply selected prompts as system prompts in ollama-buddy with a single command, streamlining your AI-assisted workflow.
Prompt Management: List available prompts, preview their content, and display full prompt details on demand.

Getting Started

To access the Awesome ChatGPT prompts, just select the transient menu as normal and select “[a] Awesome ChatGPT Prompts”, this will fetch the prompts and prepare everything for your first use and give you a transient menu as follows:

Actions
[s] Send with Prompt
[p] Set as System Prompt
[l] List All Prompts
[c] Category Browser
[S] Sync Latest Prompts
[q] Back to Main Menu

Now available are a vast array of role-based and task-specific prompts, enhancing your ollama-buddy interactions in Emacs!

Ollama-Buddy 0.9.11: Experimental ChatGPT Integration, Customizable Streaming and Texinfo documentation

James Dyer — Tue, 25 Mar 2025 10:00:00 +0000

This week in ollama-buddy updates, I have mostly been experimenting with ChatGPT integration! Yes, it is not a local LLM, so not ollama, hence entirely subverting the whole notion and fundamental principles of this package! This I know, and I don’t care; I’m having fun. I use ChatGPT and would rather use it in Emacs through the now-familiar ollama-buddy framework, so why not? I’m also working on Claude integration too.

My original principles of a no-config Emacs ollama integration still hold true, as by default, you will only see ollama models available. But with a little tweak to the configuration, with a require here and an API key there, you can now enable communication with an online AI. At the moment, I use Claude and ChatGPT, but if I can get Claude working, I might think about just adding in a basic template framework to easily slot in others. At the moment, there is a little too much internal ollama-buddy faffing to incorporate these external AIs into the main package, but I’m sure I can figure out a way to accommodate separate elisp external AIs.

In other ollama-buddy news, I have now added support for the stream variable in the ollama API. By default, I had streaming on, and I guess why wouldn’t you? It is a chat, and you would want to see “typing” or tokens arriving as they come in?. But to support more of the API, you can toggle it on and off, so if you want, you can sit there and wait for the response to arrive in one go and maybe it can be less distracting (and possibly more efficient?).

Just a note back on the topic of online AI offerings: to simplify those integrations, I just disabled streaming for the response to arrive in one shot. Mainly, I just couldn’t figure out the ChatGPT streaming, and for an external offering, I wasn’t quite willing to spend more time on it, and due to the speed of these online behemoths, do you really need to see each token come in as it arrives?

Oh, there is something else too, something I have been itching to do for a while now, and that is to write a Texinfo document so a manual can be viewed in Emacs. Of course, this being an AI-based package, I fed in my ollama-buddy files and got Claude to generate one for me (I have a baby and haven’t the time!). Reading through it, I think it turned out pretty well :) It hasn’t been made automatically available on MELPA yet, as I need to tweak the recipe, but you can install it for yourself.

Anyways, see below for the changelog gubbins:

<2025-03-24 Mon> 0.9.11

Added the ability to toggle streaming on and off

Added customization option to enable/disable streaming mode
Implemented toggle function with keybindings (C-c x) and transient menu option
Added streaming status indicator in the modeline

The latest update introduces the ability to toggle between two response modes:

Streaming mode (default): Responses appear token by token in real-time, giving you immediate feedback as the AI generates content.
Non-streaming mode: Responses only appear after they’re fully generated, showing a “Loading response…” placeholder in the meantime.

While watching AI responses stream in real-time is often helpful, there are situations where you might prefer to see the complete response at once:

When working on large displays where the cursor jumping around during streaming is distracting
When you want to focus on your work without the distraction of incoming tokens until the full response is ready

The streaming toggle can be accessed in several ways:

Use the keyboard shortcut C-c x
Press x in the transient menu

Set the default behaviour through customization:

 (setq ollama-buddy-streaming-enabled nil) ;; Disable streaming by default

The current streaming status is visible in the modeline indicator, where an “X” appears when streaming is disabled.

<2025-03-22 Sat> 0.9.10

Added experimental OpenAI support!

Yes, that’s right, I said I never would do it, and of course, this package is still very much ollama-centric, but I thought I would just sneak in some rudimentary ChatGPT support, just for fun!

It is a very simple implementation, I haven’t managed to get streaming working, so Emacs will just show “Loading Response…” as it waits for the response to arrive. It is asynchronous, however, so you can go off on your Emacs day while it loads (although being ChatGPT, you would think the response would be quite fast!)

By default, OpenAI/ChatGPT will not be enabled, so anyone wanting to use just a local LLM through ollama can continue as before. However, you can now sneak in some experimental ChatGPT support by adding the following to your Emacs config as part of the ollama-buddy set up.

(require 'ollama-buddy-openai nil t)
(setq ollama-buddy-openai-api-key "<big long key>")

and you can set the default model to ChatGPT too!

(setq ollama-buddy-default-model "GPT gpt-4o")

With this enabled, chat will present a list of ChatGPT models to choose from. The custom menu should also now work with chat, so from anywhere in Emacs, you can push predefined prompts to the ollama buddy chat buffer now supporting ChatGPT.

There is more integration required to fully incorporate ChatGPT into the ollama buddy system, like token rates and history, etc. But not bad for a first effort, methinks!

Here is my current config, now mixing ChatGPT with ollama models:

(use-package ollama-buddy
 :bind
 ("C-c o" . ollama-buddy-menu)
 ("C-c O" . ollama-buddy-transient-menu-wrapper)
 :custom
 (ollama-buddy-openai-api-key "<very long key>")
 (ollama-buddy-default-model "GPT gpt-4o")
 :config
 (require 'ollama-buddy-openai nil t)
 (ollama-buddy-update-menu-entry
 'refactor-code :model "qwen2.5-coder:7b")
 (ollama-buddy-update-menu-entry
 'git-commit :model "qwen2.5-coder:3b")
 (ollama-buddy-update-menu-entry
 'describe-code :model "qwen2.5-coder:3b")
 (ollama-buddy-update-menu-entry
 'dictionary-lookup :model "llama3.2:3b")
 (ollama-buddy-update-menu-entry
 'synonym :model "llama3.2:3b")
 (ollama-buddy-update-menu-entry
 'proofread :model "GPT gpt-4o")
 (ollama-buddy-update-menu-entry
 'custom-prompt :model "deepseek-r1:7b"))

<2025-03-22 Sat> 0.9.9

Added texinfo documentation for future automatic installation through MELPA and created an Emacs manual.

If you want to see what the manual would look like, just download the docs directory from github, cd into it, and run:

make
sudo make install-docs

Then calling up info C-h i and ollama buddy will be present in the Emacs menu, or just select m and search for Ollama Buddy

For those interested in the manual, I have converted it into html format, which is accessible here:

/tags/ollama-buddy/

It has been converted using the following command:

makeinfo --html --no-split ollama-buddy.texi -o ollama-buddy.html
pandoc -f html -t org -o ollama-buddy.org ollama-buddy.html

<2025-03-20 Thu> 0.9.9

Intro message with model management options (select, pull, delete) and option for recommended models to pull

Enhance model management and selection features
Display models available for download but not yet pulled

Ollama-Buddy 0.9.8: Transient Menu, Model Managing, GGUF Import, fabric Prompts and History Editing

James Dyer — Wed, 19 Mar 2025 16:08:00 +0000

This week in ollama-buddy updates, I have been continuing on the busy bee side of things.

The headlines are :

Transient menu - yes, I know I said I would never do it, but, well I did and as it turns out I kinda quite like it and works especially well when setting parameters.
Support for fabric prompts presets - mainly as I thought generally user curated prompts was a pretty cool idea, and now I have system prompts implemented it seemed like a perfect fit. All I needed to do was to pull the patterns directory and then parse accordingly, of course Emacs is good at this.
GGUF import - I don’t always pull from ollama’s command line, sometimes I download a GGUF file, it is a bit of a process to import to ollama, create a model file, run a command, e.t.c, but now you can import from within dired!
More support for the ollama API - includes model management, so pulling, stopping, deleting and more!
Conversation history editing - as I store the history in a hash table, I can easily just display an alist, and editing can leverage the sexp usual keybindings and then load back in to the variable.
Parameter profiles - When implementing the transient menu I thought it might be fun to try parameter profiles where a set of parameters can be applied in a block for each preset.

And now for the detail, version by version…

<2025-03-19 Wed> 0.9.8

Added model management interface to pull and delete models

Introduced `ollama-buddy-manage-models` to list and manage models.
Added actions for selecting, pulling, stopping, and deleting models.

You can now manage your Ollama models directly within Emacs with ollama-buddy

With this update, you can now:

Browse Available Models – See all installed models at a glance.
Select Models Easily – Set your active AI model with a single click.
Pull Models from Ollama Hub – Download new models or update existing ones.
Stop Running Models – Halt background processes when necessary.
Delete Unused Models – Clean up your workspace with ease.
Open the Model Management Interface Press C-c W to launch the new Model Management buffer or through the transient menu.
Manage Your Models
- Click on a model to select it.
- Use “Pull” to fetch models from the Ollama Hub.
- Click “Stop” to halt active models.
- Use “Delete” to remove unwanted models.
Perform Quick Actions
- g → Refresh the model list.
- i → Import a GGUF model file.
- p → Pull a new model from the Ollama Hub.

When you open the management interface, you get a structured list like this:

Ollama Models Management
=======================
Current Model: mistral:7b
Default Model: mistral:7b
Available Models:
[ ] llama3.2:1b Info Pull Delete
[ ] starcoder2:3b Info Pull Delete
[ ] codellama:7b Info Pull Delete
[ ] phi3:3.8b Info Pull Delete
[x] llama3.2:3b Info Pull Delete Stop
Actions:
[Import GGUF File] [Refresh List] [Pull Model from Hub]

Previously, managing Ollama models required manually running shell commands. With this update, you can now do it all from Emacs, keeping your workflow smooth and efficient!

<2025-03-19 Wed> 0.9.7

Added GGUF file import and Dired integration

Import GGUF Models into Ollama from dired with the new ollama-buddy-import-gguf-file function. In dired just navigate to your file and press C-c i or M-x ollama-buddy-import-gguf-file to start the import process. This eliminates the need to manually input file paths, making the workflow smoother and faster.

The model will then be immediately available in the ollama-buddy chat interface.

<2025-03-18 Tue> 0.9.6

Added a transient menu containing all commands currently presented in the chat buffer
Added fabric prompting support, see https://github.com/danielmiessler/fabric
Moved the presets to the top level so they will be present in the package folder

Ollama Buddy now includes a transient-based menu system to improve usability and streamline interactions. Yes, I originally stated that I would never do it, but I think it compliments my crafted simple textual menu and the fact that I have now defaulted the main chat interface to a simple menu.

This can give the user more options for configuration, they can use the chat in advanced mode where the keybindings are presented in situ, or a more minimal basic setup where the transient menu can be activated. For my use-package definition I current have the following set up, with the two styles of menus sitting alongside each other :

 :bind
 ("C-c o" . ollama-buddy-menu)
 ("C-c O" . ollama-buddy-transient-menu)

The new menu provides an organized interface for accessing the assistant’s core functions, including chat, model management, roles, and Fabric patterns. This post provides an overview of the features available in the Ollama Buddy transient menus.

Yes that’s right also fabric patterns!, I have decided to add in auto syncing of the patterns directory in https://github.com/danielmiessler/fabric

Simply I pull the patterns directory which contain prompt guidance for a range of different topics and then push them through a completing read to set the ollama-buddy system prompt, so a special set of curated prompts can now be applied right in the ollama-buddy chat!

Anyways, here is a description of the transient menu system.

The transient menu in Ollama Buddy leverages Emacs’ transient.el package (the same technology behind Magit’s popular interface) to create a hierarchical, discoverable menu system. This approach transforms the user experience from memorizing numerous keybindings to navigating through logical groups of commands with clear descriptions.

The main transient menu can be accessed with the keybinding C-c O when in an Ollama Buddy chat buffer. You can also call it via M-x ollama-buddy-transient-menu from anywhere in Emacs.

When called, the main transient menu appears at the bottom of your Emacs frame, organized into logical sections with descriptive prefixes. Here’s what you’ll see:

|o(Y)o| Ollama Buddy
[Chat] [Prompts] [Model] [Roles & Patterns]
o Open Chat l Send Region m Switch Model R Switch Roles
O Commands s Set System Prompt v View Model Status E Create New Role
RET Send Prompt C-s Show System i Show Model Info D Open Roles Directory
h Help/Menu r Reset System M Multishot f Fabric Patterns
k Kill/Cancel b Ollama Buddy Menu
[Display Options] [History] [Sessions] [Parameters]
A Toggle Interface Level H Toggle History N New Session P Edit Parameter
B Toggle Debug Mode X Clear History L Load Session G Display Parameters
T Toggle Token Display V Display History S Save Session I Parameter Help
U Display Token Stats J Edit History Q List Sessions K Reset Parameters
C-o Toggle Markdown->Org Z Delete Session F Toggle Params in Header
c Toggle Model Colors p Parameter Profiles
g Token Usage Graph

This visual layout makes it easy to discover and access the full range of Ollama Buddy’s functionality. Let’s explore each section in detail.

Chat Section

This section contains the core interaction commands:

Open Chat (o): Opens the Ollama Buddy chat buffer
Commands (O): Opens a submenu with specialized commands
Send Prompt (RET): Sends the current prompt to the model
Help/Menu (h): Displays the help assistant with usage tips
Kill/Cancel Request (k): Cancels the current ongoing request

Prompts Section

These commands help you manage and send prompts:

Send Region (l): Sends the selected region as a prompt
Set System Prompt (s): Sets the current prompt as a system prompt
Show System Prompt (C-s): Displays the current system prompt
Reset System Prompt (r): Resets the system prompt to default
Ollama Buddy Menu (b): Opens the classic menu interface

Model Section

Commands for model management:

Switch Model (m): Changes the active LLM
View Model Status (v): Shows status of all available models
Show Model Info (i): Displays detailed information about the current model
Multishot (M): Sends the same prompt to multiple models

Roles & Patterns Section

These commands help manage roles and use fabric patterns:

Switch Roles (R): Switch to a different predefined role
Create New Role (E): Create a new role interactively
Open Roles Directory (D): Open the directory containing role definitions
Fabric Patterns (f): Opens the submenu for Fabric patterns

When you select the Fabric Patterns option, you’ll see a submenu like this:

Fabric Patterns (42 available, last synced: 2025-03-18 14:30)
[Actions] [Sync] [Categories] [Navigation]
s Send with Pattern S Sync Latest u Universal Patterns q Back to Main Menu
p Set as System P Populate Cache c Code Patterns
l List All Patterns I Initial Setup w Writing Patterns
v View Pattern Details a Analysis Patterns

Display Options Section

Commands to customize the display:

Toggle Interface Level (A): Switch between basic and advanced interfaces
Toggle Debug Mode (B): Enable/disable JSON debug information
Toggle Token Display (T): Show/hide token usage statistics
Display Token Stats (U): Show detailed token usage information
Toggle Markdown->Org (C-o): Enable/disable conversion to Org format
Toggle Model Colors (c): Enable/disable model-specific colors
Token Usage Graph (g): Display a visual graph of token usage

History Section

Commands for managing conversation history:

Toggle History (H): Enable/disable conversation history
Clear History (X): Clear the current history
Display History (V): Show the conversation history
Edit History (J): Edit the history in a buffer

Sessions Section

Commands for session management:

New Session (N): Start a new session
Load Session (L): Load a saved session
Save Session (S): Save the current session
List Sessions (Q): List all available sessions
Delete Session (Z): Delete a saved session

Parameters Section

Commands for managing model parameters:

Edit Parameter (P): Opens a submenu to edit specific parameters
Display Parameters (G): Show current parameter settings
Parameter Help (I): Display help information about parameters
Reset Parameters (K): Reset parameters to defaults
Toggle Params in Header (F): Show/hide parameters in header
Parameter Profiles (p): Opens the parameter profiles submenu

When you select the Edit Parameter option, you’ll see a comprehensive submenu of all available parameters:

Parameters
[Generation] [More Generation] [Mirostat]
t Temperature f Frequency Penalty M Mirostat Mode
k Top K s Presence Penalty T Mirostat Tau
p Top P n Repeat Last N E Mirostat Eta
m Min P x Stop Sequences
y Typical P l Penalize Newline
r Repeat Penalty
[Resource] [More Resource] [Memory]
c Num Ctx P Num Predict m Use MMAP
b Num Batch S Seed L Use MLOCK
g Num GPU N NUMA C Num Thread
G Main GPU V Low VRAM
K Num Keep o Vocab Only
[Profiles] [Actions]
d Default Profile D Display All
a Creative Profile R Reset All
e Precise Profile H Help
A All Profiles F Toggle Display in Header
q Back to Main Menu

Parameter Profiles

Ollama Buddy includes predefined parameter profiles that can be applied with a single command. When you select “Parameter Profiles” from the main menu, you’ll see:

Parameter Profiles
Current modified parameters: temperature, top_k, top_p
[Available Profiles]
d Default
c Creative
p Precise
[Actions]
q Back to Main Menu

Commands Submenu

The Commands submenu provides quick access to specialized operations:

Ollama Buddy Commands
[Code Operations] [Language Operations] [Pattern-based] [Custom]
r Refactor Code l Dictionary Lookup f Fabric Patterns C Custom Prompt
d Describe Code s Synonym Lookup u Universal Patterns m Minibuffer Prompt
g Git Commit Message p Proofread Text c Code Patterns
[Actions]
q Back to Main Menu

Direct Keybindings

For experienced users who prefer direct keybindings, all transient menu functions can also be accessed through keybindings with the prefix of your choice (or C-c O when in the chat minibuffer) followed by the key shown in the menu. For example:

C-c O s - Set system prompt
C-c O m - Switch model
C-c O P - Open parameter menu

Customization

The transient menu can be customized by modifying the transient-define-prefix definitions in the package. You can add, remove, or rearrange commands to suit your workflow.

<2025-03-17 Mon> 0.9.5

Added conversation history editing

Added functions to edit conversation history (ollama-buddy-history-edit, ollama-buddy-history-save, etc.).
Updated ollama-buddy-display-history to support history editing.
Added keybinding C-c E for history editing.

Introducing conversation history editing!!

Key Features

Now, you can directly modify past interactions, making it easier to refine and manage your ollama-buddy chat history.

Previously, conversation history was static, you could view it but not change it. With this update, you can now:

Edit conversation history directly in a buffer.
Modify past interactions for accuracy or clarity.
Save or discard changes with intuitive keybindings (C-c C-c to save, C-c C-k to cancel).
Edit the history of all models or a specific one.

Simply use the new command C-c E to open the conversation history editor. This will display your past interactions in an editable format (alist). Once you’ve made your changes, press C-c C-c to save them back into Ollama Buddy’s memory.

and with a universal argument you can leverage C-c E to edit an individual model.

<2025-03-17 Mon> 0.9.1

New simple basic interface is available.

As this package becomes more advanced, I’ve been adding more to the intro message, making it increasingly cluttered. This could be off-putting for users who just want a simple interface to a local LLM via Ollama.

Therefore I have decided to add a customization option to simplify the menu.

Note: all functionality will still be available through keybindings, so just like Emacs then! :)

Note: some could see this initially as a breaking change as the intro message will look different, but rest assured all the functionality is still there (just to re-emphasize), so if you have been using it before and want the original functionality/intro message, just set :

(setq ollama-buddy-interface-level 'advanced)

(defcustom ollama-buddy-interface-level 'basic
 "Level of interface complexity to display.
'basic shows minimal commands for new users.
'advanced shows all available commands and features."
 :type '(choice (const :tag "Basic (for beginners)" basic)
 (const :tag "Advanced (full features)" advanced))
 :group 'ollama-buddy)

By default the menu will be set to Basic, unless obviously set explictly in an init file. Here is an example of the basic menu:

*** Welcome to OLLAMA BUDDY
#+begin_example
___ _ _ n _ n ___ _ _ _ _
| | | |__._|o(Y)o|__._| . |_ _ _| |_| | | |
| | | | | . | | . | . | | | . | . |__ |
|___|_|_|__/_|_|_|_|__/_|___|___|___|___|___|
#+end_example
**** Available Models
(a) another:latest (d) jamesio:latest
(b) funnyname2:latest (e) tinyllama:latest
(c) funnyname:latest (f) llama:latest
**** Quick Tips
- Ask me anything! C-c C-c
- Change model C-c m
- Cancel request C-c k
- Browse prompt history M-p/M-n
- Advanced interface (show all tips) C-c A

and of the more advanced version

*** Welcome to OLLAMA BUDDY
#+begin_example
___ _ _ n _ n ___ _ _ _ _
| | | |__._|o(Y)o|__._| . |_ _ _| |_| | | |
| | | | | . | | . | . | | | . | . |__ |
|___|_|_|__/_|_|_|_|__/_|___|___|___|___|___|
#+end_example
**** Available Models
(a) another:latest (d) jamesio:latest
(b) funnyname2:latest (e) tinyllama:latest
(c) funnyname:latest (f) llama:latest
**** Quick Tips
- Ask me anything! C-c C-c
- Show Help/Token-usage/System-prompt C-c h/U/C-s
- Model Change/Info/Cancel C-c m/i/k
- Prompt history M-p/M-n
- Session New/Load/Save/List/Delete C-c N/L/S/Y/W
- History Toggle/Clear/Show C-c H/X/V
- Prompt to multiple models C-c l
- Parameter Edit/Show/Help/Reset C-c P/G/I/K
- System Prompt/Clear C-u/+C-u +C-u C-c C-c
- Toggle JSON/Token/Params/Format C-c D/T/Z/C-o
- Basic interface (simpler display) C-c A
- In another buffer? M-x ollama-buddy-menu

<2025-03-17 Mon> 0.9.0

Added command-specific parameter customization

Added :parameters property to command definitions for granular control
Implemented functions to apply and restore parameter settings
Added example configuration to refactor-code command

With the latest update, you can now define specific parameter sets for each command in the menu, enabling you to optimize each AI interaction for its particular use case.

Different AI tasks benefit from different parameter settings. When refactoring code, you might want a more deterministic, precise response (lower temperature, higher repetition penalty), but when generating creative content, you might prefer more variation and randomness (higher temperature, lower repetition penalty). Previously, you had to manually adjust these parameters each time you switched between different types of tasks.

The new command-specific parameters feature lets you pre-configure the optimal settings for each use case. Here’s how it works:

Key Features

Per-Command Parameter Sets: Define custom parameter values for each command in your menu
Automatic Application: Parameters are applied when running a command and restored afterward
Non-Destructive: Your global parameter settings remain untouched
Easy Configuration: Simple interface for adding or updating parameters

Example Configuration

;; Define a command with specific parameters
(refactor-code
 :key ?r
 :description "Refactor code"
 :prompt "refactor the following code:"
 :system "You are an expert software engineer..."
 :parameters ((temperature . 0.2) (top_p . 0.7) (repeat_penalty . 1.3))
 :action (lambda () (ollama-buddy--send-with-command 'refactor-code)))

;; Add parameters to an existing command
(ollama-buddy-add-parameters-to-command 'git-commit
 :temperature 0.4
 :top_p 0.9
 :repeat_penalty 1.1)

;; Update properties and parameters at once
(ollama-buddy-update-command-with-params 'describe-code
 :model "codellama:latest"
 :parameters '((temperature . 0.3) (top_p . 0.8)))

This feature is particularly useful for:

Code-related tasks: Lower temperature for more deterministic code generation
Creative writing: Higher temperature for more varied and creative outputs
Technical explanations: Balanced settings for clear, accurate explanations
Summarization tasks: Custom parameters to control verbosity and focus

<2025-03-16 Sun> 0.8.5

Added system prompt support for commands

Introduced `:system` field to command definitions.
Added `ollama-buddy-show-system-prompt` to view active system prompt.
Updated UI elements to reflect system prompt status.

Previously, individual menu commands in ollama-buddy only included a user prompt. Now, each command can define a system prompt, which provides background context to guide the AI’s responses. This makes interactions more precise and tailored.

Key Features

System prompts per command: Specify background instructions for each AI-powered command using the new :system field.
View active system prompt: Use C-c C-s to display the current system prompt in a dedicated buffer.
Updated UI elements: The status line now indicates whether a system prompt is active.

A helper function has also been added to update the default menu, for example, you might want to tweak a couple of things:

(use-package ollama-buddy
 :bind ("C-c o" . ollama-buddy-menu)
 :custom
 (ollama-buddy-default-model "llama3.2:3b")
 :config
 (ollama-buddy-update-menu-entry
 'refactor-code
 :model "qwen2.5-coder:7b"
 :system "You are an expert software engineer who improves code and only mainly using the principles exhibited by Ada")
 (ollama-buddy-update-menu-entry
 'git-commit
 :model "qwen2.5-coder:3b"
 :system "You are a version control expert and mainly using subversion"))

Ollama-Buddy 0.8.0 - Added System Prompts, Model Info and simpler menu model assignment

James Dyer — Fri, 14 Mar 2025 13:21:00 +0000

More improvements to ollama-buddy https://github.com/captainflasmr/ollama-buddy

The main addition is that of system prompts, which allows setting the general tone and guidance of the overall chat. Currently the system prompt can be set at any time and turned on and off but I think to enhance my model/command for each menu item concept, I could also add a :system property to the menu alist definition to allow even tighter control of a menu action to prompt response.

Also now I have parameter functionality working for fine grained control, I could add these individual parameters for each menu command, for example the temperature could be very useful in this case to play around with the randomness/casualness of the response.

The next improvement will likely involve adding support for interacting more directly with Ollama to create and pull models. However, I’m still unsure whether performing this within Emacs is the best approach, I could assume that all models are already set up in Ollama.

That said, importing a GGUF file might be a useful feature, possibly from within dired. Currently, this process requires multiple steps: creating a simple model file that points to the GGUF file on disk, then running the ollama create command to import it. Streamlining this workflow could enhance usability.

Then maybe on to embeddings, of which I currently have no idea, haven’t read up on it, nuffin, but that is something to look forward to! :)

Anyways, here is the latest set of updates to Ollama Buddy:

<2025-03-14 Fri> 0.8.0

Added system prompt support

Added ollama-buddy--current-system-prompt variable to track system prompts
Updated prompt area rendering to distinguish system prompts
Modified request payload to include system prompt when set
Enhanced status bar to display system prompt indicator
Improved help menu with system prompt keybindings

So this is system prompt support in Ollama Buddy!, allowing you to set and manage system-level instructions for your AI interactions. This feature enables you to define a persistent system prompt that remains active across user queries, providing better control over conversation context.

Key Features

You can now designate any user prompt as a system prompt, ensuring that the AI considers it as a guiding instruction for future interactions. To set the system prompt, use:

C-u C-c C-c

Example:

Type:

Always respond in a formal tone.

Press C-u C-c C-c This prompt is now set as the system prompt and any further chat ollama responses will adhere to the overarching guidelines defined in the prompt.

If you need to clear the system prompt and revert to normal interactions, use:

C-u C-u C-c C-c

How It Works

The active system prompt is stored and sent with each user prompt.
A “S” indicator appears in the status bar when a system prompt is active.
The request payload now includes the system role, allowing AI to recognize persistent instructions.

Demo

Set the system message to:

You must always respond in a single sentence.

Now ask the following:

Tell me why Emacs is so great!

Tell me about black holes

clear the system message and ask again, the responses should now be more verbose!!

<2025-03-13 Thu> 0.7.4

Added model info command, update keybindings

Added `ollama-buddy-show-raw-model-info` to fetch and display raw JSON details of the current model in the chat buffer.
Updated keybindings:
- `C-c i` now triggers model info display.
- `C-c h` mapped to help assistant.
- Improved shortcut descriptions in quick tips section.
Removed unused help assistant entry from menu.
Changed minibuffer-prompt key from `?i` to `?b`.

<2025-03-12 Wed> 0.7.3

Added function to associate models with menu commands

Added ollama-buddy-add-model-to-menu-entry autoload function
Enabled dynamic modification of command-model associations

This is a helper function that allows you to associate specific models with individual menu commands.

Configuration to apply a model to a menu entry is now straightforward, in your Emacs init file, add something like:

(with-eval-after-load 'ollama-buddy
 (ollama-buddy-add-model-to-menu-entry 'dictionary-lookup "tinyllama:latest")
 (ollama-buddy-add-model-to-menu-entry 'synonym "tinyllama:latest"))

This configures simpler tasks like dictionary lookups and synonym searches to use the more efficient TinyLlama model, while your default model will still be used for more complex operations.

<2025-03-12 Wed> 0.7.2

Added menu model colours back in and removed some redundant code

Ollama-Buddy 0.7.1 - Org-mode Chat, Parameter Control and JSON Debugging

James Dyer — Tue, 11 Mar 2025 18:07:00 +0000

Continuing the development of my local ollama LLM client called ollama-buddy…

https://github.com/captainflasmr/ollama-buddy

The basic functionality, I think, is now there (and now literally zero configuration required). If a default model isn’t set I just pick the first one, so LLM chat can take place immediately.

Now I’m getting more into this chat client malarkey, my original idea of a very minimal chat client to interface to ollama is starting to skew into supporting as much of the ollama RESTful API as possible. Hence in this update a more advanced approach is creeping in, including setting up various subtle model parameters and providing a debugging window to monitor incoming raw JSON (pretty printed of course). Hopefully, these features will remain tucked away for advanced users, I’ve done my best to keep them unobtrusive (but not too hidden). The tool is still designed to be a helpful companion to interface to ollama through Emacs, just now with more powerful options under the hood.

Also a note about converting the chat buffer into org-mode. My original intention was to keep the chat buffer as a very simple almost “no mode” buffer, with just text and nothing else. However, with more consideration, I felt that converting this buffer into org-mode actually held quite a few benefits:

Each prompt could be a heading, hence outlining and folding can be activated!
Navigation between prompts now comes for free (especially if you are using org-use-speed-commands)
The org ox export backend now allows us to export to formats of many different kinds

I’m sure there are more as this list isn’t quite the “quite a few benefits” I was hoping for :(

I have a local keymap defined with some ollama-buddy specific keybindings, and as of yet I haven’t encountered any conflicts with commonly used org-mode bindings but we shall see how it goes. I think for this package it is important to have a quick chatting mechanism, and what is faster than a good keybind?

Finally, just a note on the pain of implementing a good prompt mechanism. I had a few goes at it and I think I now have an acceptable robust solution. I kept running into little annoying edge cases and I ended up having to refactor quite a bit. My original idea for this package involved a simple “mark region and send” as at the time I had a feeling that the implementation of a good prompt mechanism would be tough - how right I was!. Things got even trickier with the move to org-mode, since each prompt heading should contain meaningful content for clean exports and I had to implement a mechanism to replace prompts intelligently. For example, if the model is swapped and the previous prompt is blank, it gets replaced, though, of course, even this has its own edge cases - gives a new meaning to prompt engineering! :)

Anyways, listed below are my latest changes, with a little deeper dive into more “interesting” implementations, my next ideas are a little more advanced and are kanban’d into my github README at https://github.com/captainflasmr/ollama-buddy for those that are interested.

<2025-03-11 Tue> 0.7.1

Added debug mode to display raw JSON messages in a debug buffer

Created new debug buffer to show raw JSON messages from Ollama API
Added toggle function to enable/disable debug mode (ollama-buddy-toggle-debug-mode)
Modified stream filter to log and pretty-print incoming JSON messages
Added keybinding C-c D to toggle debug mode
Updated documentation in welcome message

<2025-03-11 Tue> 0.7.0

Added comprehensive Ollama parameter management

Added customization for all Ollama option API parameters with defaults
Only send modified parameters to preserve Ollama defaults
Display active parameters with visual indicators for modified values
Add keybindings and help system for parameter management
Remove redundant temperature controls in favor of unified parameters

Introduced parameter management capabilities that give you complete control over your Ollama model’s behavior through the options in the ollamas API.

Ollama’s API supports a rich set of parameters for fine-tuning text generation, from controlling creativity with temperature to managing token selection with top_p and top_k. Until now, Ollama Buddy only exposed the temperature parameter, but this update unlocks the full potential of Ollama’s parameter system!

Key Features:

All Parameters - set all custom options for the ollama LLM at runtime
Smart Parameter Management: Only modified parameters are sent to Ollama, preserving the model’s built-in defaults for optimal performance
Visual Parameter Interface: Clear display showing which parameters are active with highlighting for modified values

Keyboard Shortcuts

Parameter management is accessible through simple keyboard shortcuts from the chat buffer:

C-c P - Edit a parameter
C-c G - Display current parameters
C-c I - Show parameter help
C-c K - Reset parameters to defaults

<2025-03-10 Mon> 0.6.1

Refactored prompt handling so each org header line should now always have a prompt for better export

Added functionality to properly handle prompt text when showing/replacing prompts
Extracted inline lambdas in menu actions into named functions
Added fallback for when no default model is set

<2025-03-08 Sat> 0.6.0

Chat buffer now in org-mode

Enabled org-mode in chat buffer for better text structure
Implemented ollama-buddy--md-to-org-convert-region for Markdown to Org conversion
Turn org conversion on and off
Updated keybindings C-c C-o to toggle Markdown to Org conversion

Key Features

The chat buffer is now in org-mode which gives the buffer enhanced readability and structure. Now, conversations automatically format user prompts and AI responses with org-mode headings, making them easier to navigate.
Of course with org-mode you will now get the additional benefits for free, such as:
- outlining
- org export
- heading navigation
- source code fontification
Previously, responses in Ollama Buddy were displayed in markdown formatting, which wasn’t always ideal for org-mode users. Now, you can automatically convert Markdown elements, such as bold/italic text, code blocks, and lists, into proper org-mode formatting. This gives you the flexibility to work with markdown or org-mode as needed.

Ollama Buddy Version 0.2.1 - Same prompt to multiple LLMs and choose best answer!

James Dyer — Sun, 02 Mar 2025 09:35:00 +0000

Some improvements to my ollama LLM package…

With the new multishot mode, you can now send a prompt to multiple models in sequence, and compare their responses, the results are also available in named registers.

Letter-Based Model Shortcuts

Instead of manually selecting models, each available model is now assigned a letter (e.g., (a) mistral, (b) gemini). This allows for quick model selection when sending prompts or initiating a multishot sequence.

Multishot Execution (C-c C-l)

Ever wondered how different models would answer the same question? With Multishot Mode, you can:

Send your prompt to a sequence of models in one shot.
Track progress as responses come in.
Store each model’s response in a register, making it easy to reference later, each assigned model letter corresponds to the named register.

Status Updates

When running a multishot execution, the status now updates dynamically:

“Multi Start” when the sequence begins.
“Processing…” during responses.
“Multi Finished” when all models have responded.

How It Works

C-c C-l to start a multishot session in the chat buffer.
Type a sequence of model letters (e.g., abc to use models mistral, gemini, and llama).
The selected models will process the prompt one by one.
The responses will be saved to registers of the same named letter for recalling later.

Ollama-Buddy on Emacs@ Dyerdwelling

Ollama Buddy - Web Search Integration

Ollama Buddy v2.5 - RAG (Retrieval-Augmented Generation) Support

What even is RAG?

Getting started

Indexing your documents

The chunking strategy

Searching and attaching context

A practical example

That’s pretty much it!

Ollama Buddy v2.0 - LLMs can now call Emacs functions!

Spent a bit of free time polishing ollama-buddy - github Copilot is now onboard!

Ollama buddy now supports cloud models!

<2026-01-28 Wed> 1.1

Expanding Ollama Buddy: Mistral Codestral Integration

Ollama Buddy v1.0: A Simple AI Assistant

Why Choose Ollama Buddy?

Links

Key Features

Multiple AI Providers

Role-Based Workflows - build your own AI menu

Chat Interface

File Handling

Prompt Management

Session Management

Flexible Interface Options

What’s Next?

Ollama Buddy 0.12.0: User Prompt Library, File Attachments, Vision and Context Tracking

<2025-05-22 Thu> 0.12.0

<2025-05-21 Wed> 0.11.1

<2025-05-19 Mon> 0.11.0

<2025-05-14 Wed> 0.10.0

<2025-05-12 Mon> 0.9.50

Usage

Implementation Details

Context Size Detection

Token Estimation

How to Use Context Management in Practice

Typical Workflows

Current Status: Experimental

More Details

<2025-05-05 Mon> 0.9.44

<2025-05-05 Mon> 0.9.43

<2025-05-03 Sat> 0.9.42

<2025-05-02 Fri> 0.9.41

<2025-05-02 Fri> 0.9.40

Ollama-Buddy 0.9.38: Unload Models, Hide AI Reasoning, and Clearly View Modified Parameters on each request

<2025-04-29 Tue> 0.9.38

<2025-04-25 Fri> 0.9.37

<2025-04-25 Fri> 0.9.36

Ollama-Buddy 0.9.35: Grok, Gemini Integration and Enhanced Sessions

🎉 New AI Integrations with Grok and Gemini

🔗 Improved Remote LLM Architecture

🎯 Standardized Model Prefixing

💾 Enhanced Session Management

🛠️ Additional Improvements

<2025-04-21 Mon> 0.9.35

<2025-04-20 Sun> 0.9.33

<2025-04-19 Sat> 0.9.32

<2025-04-18 Fri> 0.9.31

<2025-04-17 Thu> 0.9.30

<2025-04-16 Wed> 0.9.23

<2025-04-15 Tue> 0.9.22

<2025-04-11 Fri> 0.9.21

Ollama-Buddy 0.9.20: Curated AI Prompting with Awesome ChatGPT Prompts

Key Features

Getting Started

Ollama-Buddy 0.9.11: Experimental ChatGPT Integration, Customizable Streaming and Texinfo documentation

<2025-03-24 Mon> 0.9.11

<2025-03-22 Sat> 0.9.10

<2025-03-22 Sat> 0.9.9

<2025-03-20 Thu> 0.9.9

Ollama-Buddy 0.9.8: Transient Menu, Model Managing, GGUF Import, fabric Prompts and History Editing

<2025-03-19 Wed> 0.9.8

<2025-03-19 Wed> 0.9.7

<2025-03-18 Tue> 0.9.6

What is the Transient Menu?

Accessing the Menu

What the Menu Looks Like

Menu Sections Explained