Andes

A Visual Studio Code (or Cursor, Windsurf etc) extension that provides a local UI interface for Ollama models.

This project is no longer actively maintained and may contain bugs. I recommend using Cline instead.

Install it on VS Marketplace or Open VSX

Requirements

For local development without containers:

• Node.js
• Go
• VS Code
• make
• Ollama

For containerized development:

• Docker Desktop or another Docker-compatible runtime
• VS Code with the Dev Containers extension

Important: a VS Code extension by itself cannot run Docker containers on a user's machine. If the user does not have Docker or another OCI runtime installed locally, the practical alternative is a remote container environment such as GitHub Codespaces, a remote Docker host, or a pre-provisioned dev VM.

How to build

Local host setup

Set environment variables in .env, copying values from .env.example.

Before testing, make sure you have code installed in your PATH.

• Press CMD + Shift + P and search for Shell Command: Install 'code' command in PATH
• Restart VS Code

Then start the project:

• Run make install
• Start Ollama with ollama serve
• Start the Go API with go run ./cmd/andes
• Run F5 in VS Code to open the Extension Development Host
• Use make build-local when you only want to rebuild the extension bundle locally

Docker Compose setup

This repository now includes docker-compose.yml with three services:

• ollama: runs the Ollama server and stores pulled models in the ollama-data volume
• backend: runs the Go markdown conversion API from ./cmd/andes and exposes port 11212
• static: serves the extension's static/ assets through nginx on port 8080 for preview/debugging

Start the stack:

make build

After the stack is up:

• open http://localhost:8080 to preview the static assets
• use http://localhost:11434 for Ollama
• use http://localhost:11212 for the Go conversion API
• pull at least one model with make pull-model
• stop the stack with make down
• inspect logs with make logs

The packaged extension still reads its UI from the bundled static/ files inside VS Code. The static container exists for browser preview and asset debugging, not because the extension requires nginx in production.

Recommended future test flow

For Docker-based testing:

• run make install once
• run make build
• run make pull-model
• press F5 in VS Code
• test the extension against the Docker services published on localhost

For normal local packaging and production-style extension build:

• run make build-local
• package/publish the extension normally

Production behavior is unchanged: the extension still runs normally in VS Code and talks to whichever Ollama and Go API endpoints you configure.

VS Code Dev Container

The .devcontainer/ folder opens the workspace in a container and wires the extension host to the Compose services automatically:

• OLLAMA_HOST=ollama
• GOLANG_API_HOST=backend

Open the project in VS Code and run Dev Containers: Reopen in Container. The workspace container installs Node.js tooling plus Go, while the Compose stack starts ollama, backend, and static.

Connection settings

The extension now supports configurable endpoints through VS Code settings or environment variables:

• andes.ollamaHost / OLLAMA_HOST
• andes.ollamaPort / OLLAMA_PORT
• andes.golangApiHost / GOLANG_API_HOST
• andes.golangApiPort / GOLANG_API_PORT

This makes it possible to use the same extension against local services, Docker-published host ports, or service names inside a dev container.

Features

• Manage your installed Ollama models locally;
• Chat with AI;
• Observe the reasoning process and decision-making of AI models.

Changelog

Visit CHANGELOG.md.

TODO

Visit TODO.md.

About project

I created Andes to provide a simple, authentication-free VS Code extension that works exclusively with Ollama models in VSC, Windsurf, Trae, Cursor and other VSC forks. While other plugins like Cline & Continue support multiple AI providers with authentication needed, I wanted a focused solution specifically for local Ollama models.

Sadly it's written in TypeScript, but API for Markdown-to-HTML formating is in Golang. Initially i wanted to write this project in Golang, but it's simplier to write it in TypeScript since i can request Ollama's endpoints directly from TypeScript.