Swipeer Documentation

Welcome to the command center. Swipeer is more than just a chat window—it's a local-first, model-agnostic workspace designed to bridge the gap between AI and your actual files.

Local-First Architecture

Your chat-history, notes, and knowledge-base data is only stored locally on your device.

BYOK Flexibility

Use your own OpenRouter keys or run Swipeer offline with Ollama for unlimited access without credit limits.

MCP Tooling

Extend your AI with real-time tools via Model Context Protocol. Connect servers or run local scripts.

Quick Installation

Swipeer is a high-performance native desktop application built with Electron. Follow the instructions for your operating system:

Windows

Run the .exe installer and follow the wizard.

x64 / ARM64
macOS

Drag Swipeer.app to your Applications folder.

Intel / Silicon
Linux

Make the AppImage executable and launch.

AppImage

Permissions

On Linux, you may need to run: chmod +x Swipeer-v1.0.0.AppImage

Quickstart Setup

Get up and running with Swipeer in less than two minutes. Follow these simple steps to start boosting your productivity immediately.

1 Activate your License

Once you have purchased a license or registered for the Free Tier, you will receive an email containing your License Key. Open the app, go to Settings ➔ License, paste your key into the text field, and click Activate.

2 Set up AI Providers (Optional)

All users have access to cloud models out of the box using their Swipeer credits. However, if you are a Pro or Business user and want to use your own API keys via OpenRouter (BYOK), or if you want to use local models via Ollama, navigate to Settings ➔ Providers to enter your details. Check the OpenRouter section for more info.

The Most Important Step: Use the Shortcut!

Swipeer is designed to be your instantly accessible assistant. You don't need to keep the app window open in the background. Simply press the global shortcut:

Windows & Linux: Ctrl + Space
macOS: Option + Space

This will instantly summon Swipeer on top of any application you are currently using, without breaking your flow. .

OpenRouter

OpenRouter

OpenRouter is our recommended provider for accessing unlimited usage with your own API key.

1 Create Account

Register at OpenRouter and add some credits to your balance.

2 Copy API Key

Go to Keys under your profile and generate a new key for Swipeer.

3 Setup in App

Go to Settings ➔ Providers, expand OpenRouter, paste the key, and activate the checkbox. Save and you are ready!

Important Note: You can either have OpenRouter OR your Swipeer Credits activated, but not both at the same time. If you check the box to activate OpenRouter, Swipeer will route requests through your OpenRouter key instead of your Swipeer subscription logic.

Why OpenRouter?

  • Access models from 10+ different companies
  • Pay only for what you use at wholesale prices
  • No monthly subscriptions for each model
View the illustrated setup guide

Local Privacy & Cloud: Ollama

Run local models like Qwen or Mistral entirely on your own machine, or connect directly to Ollama Cloud. For more information, visit Ollama.

Option 1: Complete Local Privacy

Requires powerful GPU

$ ollama run qwen3
$ ollama run gemma3:4b

Option 2: Ollama Cloud (Local Proxy)

Run massive models without draining your own GPU resources. Sign in via your terminal, and your local Ollama daemon will securely route requests to the cloud.

$ ollama signin
$ ollama run glm-5:cloud

In Swipeer, leave the Endpoint URL as http://localhost:11434 (no API key needed).
Note: You need to run models via terminal (e.g. 'ollama run gemma3:4b' or 'ollama run glm-5:cloud') once before they appear in Swipeer.
Also note that Ollama Cloud has usage limits which you can view at ollama.com/settings.

Option 3: Direct API / Custom Remote Servers

If you don't want to run Ollama locally at all, or if you have your own secured remote VPS server, you can configure Swipeer to connect directly.

  1. Go to Settings ➔ Providers
  2. Change the Endpoint URL to your server or https://ollama.com
  3. Enter your API Key / Token if the server is secured.

Swipeer automatically fetches all models available to your account!

Swipeer automatically pings http://127.0.0.1:11434 by default. If you run Ollama on a different port, update the URL in Settings ➔ Providers.

💬

Chat History

Never lose a conversation again. Access your entire chat history via the folder icon in the sidebar. Use the search bar to find specific discussions instantly.

🎭

System Prompt (Persona)

Define the personality and behavior of your AI. Set a global instruction like "You are a Senior React Developer who prefers functional programming" to ensure every new chat starts with the right context and tone.

📋

Smart Templates

Save and reuse your most powerful prompts. Type any character in the chat input to trigger the autosuggestion process and press TAB or Enter to add your template to the chat.

Built-in Presets:

Grammar Check Summarize Translate to... Explain Code
📝

Notes & Knowledge Base

A built-in Markdown Editor for your documentation, code snippets, and ideas. But it's more than just notes—it's your AI's long-term memory.

Context Injection

Toggle "Knowledge Base" on any note to strictly inject it into the AI's context window. Perfect for project requirements, API documentation, or coding guidelines.

100% Local & Private

Your notes never leave your machine (unless you choose a cloud model). No vector databases, no complex setup—just pure text context.

HTTP Automations

Swipeer includes a built-in HTTP client (similar to Postman/Insomnia) that allows you to trigger external events or send data to other apps via webhooks and APIs.

Supported Methods

  • GET
  • POST (JSON / Form Data)
  • PUT / PATCH
  • DELETE

Advanced Auth

  • Bearer Token
  • Basic Auth
  • Custom API-Key Headers

Integration Examples

01

n8n / Make.com: Send data to a webhook to start a complex workflow (e.g., creating a JIRA ticket, saving a note to Notion, or emailing a summary).

02

Local API Testing: Test your developer endpoints without leaving the context of your AI pair-programmer.

🔌

Tools & Integrations

Expertise Gallery & MCP Servers

Discover pre-configured expertise scripts and MCP integrations to boost your productivity.

Browse Gallery →

Swipeer includes secure tools for local files and web browsing. You can also extend the AI with custom Expertises and external Model Context Protocol (MCP) servers.

Built-in Swipeer Tools

Local Files and Web Browser are included with Swipeer. There is nothing to install, and users do not need Node.js. On a new installation, Swipeer connects both tools automatically when a supported browser is available. Existing tool settings and tools you explicitly disconnected are never overwritten.

📁

Local Files

  1. Open Settings ➔ Integrations.
  2. Open Local Files settings with the gear button.
  3. Review the pre-approved Desktop and Swipeer Expertise folders.
  4. Choose Add folder, or enter an absolute path such as ~/.config/... for a hidden Linux folder.

Swipeer cannot access folders outside this list. You can remove either default; removing the final allowed folder disconnects Local Files and revokes all filesystem access.

🌐

Web Browser

  1. Open Settings ➔ Integrations.
  2. Open Web Browser settings with the gear button.
  3. Swipeer selects and connects the first supported installed browser on initial setup.
  4. Choose another installed browser at any time; reconnect manually if you previously disconnected the tool.

Swipeer uses a separate persistent agent profile. Chrome, Edge, and Chromium are supported; Firefox support is currently beta.

How it works: Swipeer packages and manages the required runtime internally. MCP remains the secure tool interface under the hood, but no MCP command, package installation, or system Node.js setup is required.

External MCP Servers

Connect to external MCP servers (like Supabase, n8n, or GitHub) to give your AI access to live data and specialized actions.

  1. Go to Settings ➔ Integrations.
  2. Enter the Server URL (MCP endpoint) and a descriptive Name.
  3. (Optional) Add an API Key or custom Header Name if required by the server.
  4. Click Test Connection to verify, then Add Server.

Live Example: Supabase MCP

Server URL
https://mcp.supabase.com/mcp?project_ref=your_project_id
Header Name
Authorization
API Key / Token
sbp_your_access_token
💡

Auto-Bearer: Swipeer automatically adds the Bearer prefix for you when using the Authorization header. Just paste the raw token!

Official Service Use a Personal Access Token from your Account Settings ➔ Access Tokens.
Custom Edge Function Use your project's anon / public key from API Settings ➔ API Keys.

Method 1: Local Expertise (Custom Scripts)

Turn your local automations into AI-Skills. Swipeer supports Node.js and Python scripts via stdio communication. These scripts run in the background and can access your local filesystem, execute shell commands, or query local databases.

Script Anatomy

1
SDK Imports

Import the MCP Server and Transport classes. Important: In Swipeer, you must append .js to all internal SDK paths.

2
List Tools

Register your tool names, descriptions, and JSON Schema definitions so the AI knows when and how to call them.

3
Call Tool Handler

Implement the actual logic. This is where you run your Node/Python code based on the AI's requested arguments.

4
Stdio Transport

Connect your server to StdioServerTransport. Swipeer communicates with your script via standard input/output.

Zero Install Environment

You don't need npm install. Swipeer provides the SDK internally. Simply point to tools.js and it just works.

tools.js (Node.js Template)
// 1. Imports (Notice the .js extensions!)
const { Server } = require("@modelcontextprotocol/sdk/server/index.js");
const { StdioServerTransport } = require("@modelcontextprotocol/sdk/server/stdio.js");
const { ListToolsRequestSchema, CallToolRequestSchema } = require("@modelcontextprotocol/sdk/types.js");

// 2. Initialize Server
const server = new Server(
  { name: "custom-skill", version: "1.0.0" },
  { capabilities: { tools: {} } }
);

// 3. Register available tools
server.setRequestHandler(ListToolsRequestSchema, async () => ({
  tools: [{
    name: "calculate_revenue",
    description: "Calculates total revenue from a local CSV",
    inputSchema: { 
      type: "object", 
      properties: { 
        year: { type: "number", description: "Filter by year" } 
      }
    }
  }]
}));

// 4. Implementation logic
server.setRequestHandler(CallToolRequestSchema, async (request) => {
  const { name, arguments: args } = request.params;
  
  if (name === "calculate_revenue") {
    // Your custom logic here
    const result = "Year " + args.year + " revenue: $1.2M";
    return { 
      content: [{ type: "text", text: result }] 
    };
  }
  
  throw new Error("Tool not found");
});

// 5. Start Communication
server.connect(new StdioServerTransport());

Common Pitfall: Module Paths

Unlike standard Node projects, Swipeer requires exact paths for internal modules. Always use .../index.js or .../stdio.js instead of just the folder names.

Built-in Tools & Package Expertises

Local Files and Web Browser are configured directly in Swipeer. Third-party community tools can still be added as package Expertises via npx.

Node.js is only required for third-party npx packages

Swipeer's built-in tools need no system Node.js installation. To execute a custom npx package, install Node.js, which includes npm and npx.

Example: Local Files (Built-in)

Allows the AI to read, write, and manage files only inside folders you explicitly approve. Use it to edit code, analyze documents, organize files, and automate local workflows without exposing the rest of your computer.

💡

New installations allow the Desktop and Swipeer's Expertise folder by default. Use the gear button to add folders with the picker or paste an absolute path such as ~/.config/... when a hidden Linux directory is not visible.

Availability: Included with Swipeer
Setup: Connected automatically
Runtime: Managed by Swipeer

Full Settings Reference

Category Features
GUI & Layout Theme selection (Light/Dark), Font scaling (80% - 150%), Window staying behavior, and language selection.
License Enter your key, check credit consumption, and see feature locks for Starter/Pro tiers.
Providers Configure OpenRouter keys and custom Ollama endpoints. This is the heart of your AI engine.
Integrations Configure built-in Local Files and Web Browser tools, custom Expertises, and external MCP servers.
Profile (Backup) Export/Import your configuration. Perfect for transferring your setup to a new machine or backing up your templates.
⌨️

Keyboard Shortcuts

Speed up your workflow. Click the keyboard icon at the bottom of the sidebar to view a live map of all available shortcuts, including quick-create commands, window toggles, and navigation keys.