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

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.

🔌

Integrations (MCP)

Expertise Gallery & MCP Servers

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

Browse Gallery →

Swipeer supports the Model Context Protocol (MCP), allowing you to extend the AI's capabilities with real-time tools, databases, and local scripts.

Remote 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 (SSE 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 KI-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.

Method 2: Package Expertises (npx)

You can also add ready-to-use MCP servers directly via npx without writing any code. Ideal for documentation servers or pre-built community tools.

Prerequisite: Node.js & npm/npx

To execute npx packages on your system, you must have Node.js (which bundles npm and npx) installed globally on your computer.

Example: Server-Filesystem (Computer Access)

Allows the AI to read, write, and manage files on your local drive. This is highly useful for giving Swipeer full access to your workspace directories, allowing it to edit code, analyze files, and automate tasks directly on your computer.

💡

Specify absolute paths to folders you want the AI to access as arguments. Separate multiple directories with spaces.

Name: Server-Filesystem
Command: npx
Arguments: -y @modelcontextprotocol/server-filesystem /home/user/Desktop

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 Manage MCP servers and Local Expertise scripts. Extend your AI with powerful real-time tools.
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.