Pomera AI Commander

AI Tools - Access AI language models via MCP

Generate text using various AI providers including Google AI, OpenAI, Anthropic, Groq, OpenRouter, Azure AI, Vertex AI, Cohere, HuggingFace, LM Studio, and AWS Bedrock.

WHEN TO USE THIS TOOL:

• Generate, summarize, or transform text using AI
• Use specific AI providers/models for different tasks
• Process file content through AI models
• Execute research queries with deep reasoning and web search
• Run structured deep reasoning analysis

KEY FEATURES: ✅ 11 AI providers supported ✅ File input/output support ✅ System prompt configuration ✅ Sampling parameters (temperature, top_p, top_k) ✅ Content parameters (max_tokens, stop_sequences) ✅ Research mode with extended reasoning + web search ✅ Deep reasoning with 6-step protocol

ACTIONS:

• list_providers: Get list of available AI providers
• list_models: Get models for a specific provider
• generate: Generate text using AI (default action)
• research: Research with deep reasoning + web search (OpenAI/Anthropic/OpenRouter/Google AI)
• deepreasoning: Extended thinking with 6-step protocol (Anthropic only)

RESEARCH ACTION (OpenAI, Anthropic AI, OpenRouterAI & Google AI):

• OpenAI: GPT-5.5 with reasoning_effort (xhigh)
• Anthropic: Claude Opus 4.8 with adaptive thinking and search_count
• OpenRouter: Various models (gemini-3-flash, sonar-deep-research) with max_results
• Google AI: Deep Research via Interactions API (deep-research-preview, async polling)
• Mode: two-stage (search → reason) or single (combined)
• Style presets: analytical, concise, creative, report

DEEPREASONING ACTION (Anthropic AI only):

• Uses Claude Opus 4.8 Adaptive Thinking
• 6-step protocol: Decompose → Search → Decide → Analyze → Verify → Synthesize
• Optional web search during reasoning
• Thinking budget control (1K-128K tokens)

BEST PRACTICES FOR AI AGENTS:

1. Use 'list_providers' to see available providers
2. Use 'list_models' to see models for a provider
3. API keys must be configured via Pomera UI (not passed as params)
4. Use system_prompt for consistent behavior
5. Use 'research' for complex queries needing web data
6. Use 'deepreasoning' for structured analysis problems

OUTPUT STRUCTURE: { 'success': bool, 'response': str, 'provider': str, 'model': str, 'error': str or null }

Text analysis and comparison tools. Actions: stats (character/word/line/sentence counts, reading time), frequency (word frequency analysis with sorting), compare_lists (compare two lists: all/only_a/only_b/in_both), html (HTML visible text, cleaning, links, images, headings, tables, forms). Can save selected outputs to files.

Data conversion and encoding tools. Actions: json_xml (prettify/minify/validate/convert JSON and XML), columns (extract, reorder, delete, transpose, or fixed-width CSV columns), encode (base64 encode/decode, hash generation, number base conversion), generate (passwords, UUIDs, lorem ipsum, random emails, URL slugs), timestamp (Unix timestamp/date conversion). All actions support file input/output where applicable.

Regex find/replace with diff preview and automatic backup to Notes. Designed for AI agent workflows requiring verification and rollback capability. Operations: validate (check regex), preview (show diff), execute (replace+backup), recall (retrieve previous). FILE-BASED WORKFLOW: Set text_is_file=true to load content from a file path instead of inline text. Use output_to_file to save the replaced result to a file. Use diff_to_file to save the diff preview to a file. Example: text='/path/to/file.py', text_is_file=true, find_pattern='old_func', replace_pattern='new_func', output_to_file='/path/to/output.py', diff_to_file='/path/to/changes.diff'

Pomera Notes - Persistent note-taking system for AI agent memory and backup

Manage notes in Pomera's database with full-text search, encryption, and dual input/output fields. Notes persist across sessions and can be searched with FTS5 wildcards.

WHEN TO USE THIS TOOL:

• Save code snapshots before refactoring (rollback capability)
• Create persistent memory across AI sessions (prevent context loss)
• Store research findings, URLs, and documentation notes
• Document architectural decisions and rationale
• Save session progress for resuming later
• Backup important text before risky operations
• Store sensitive data with encryption (API keys, credentials)

KEY FEATURES: ✅ Dual fields: input_content (source/before) and output_content (result/after) ✅ Full-text search with FTS5 (supports wildcards: *) ✅ Automatic encryption for sensitive data (API keys, passwords, tokens) ✅ File loading: load content directly from file paths ✅ UTF-8 sanitization (handles invalid surrogate characters) ✅ Persistent storage in SQLite database

ENCRYPTION FEATURES:

• encrypt_input: Encrypt input content at rest
• encrypt_output: Encrypt output content at rest
• auto_encrypt: Auto-detect and encrypt sensitive data (API keys, passwords, tokens, credit cards, SSNs)
• Automatic decryption on retrieval (transparent to user)
• Machine-specific encryption key (PBKDF2 + Fernet)

FILE LOADING:

• Set input_content_is_file: true to load from file path
• Set output_content_is_file: true to load from file path
• Supports absolute and relative paths
• UTF-8 encoding with Latin-1 fallback

ACTIONS:

• save: Create new note (requires title)
• get: Retrieve note by ID (automatic decryption)
• list: List notes, optionally filtered by FTS5 search
• search: Full-text search with content preview
• update: Modify existing note (requires note_id)
• delete: Remove note (requires note_id)

BEST PRACTICES FOR AI AGENTS:

1. Naming Convention: Use hierarchical titles for organization

• Format: Category/Subcategory/Description-Date
• Examples: Memory/Session/BlogPost-2025-01-25, Code/Component/Original-2025-01-10
• Categories: Memory, Code, Research, Session, Deleted, Translation

2. Dual Fields Strategy:

• input_content: Original/source/before state
• output_content: Result/processed/after state
• Example: input=user request, output=AI response

3. Search with Wildcards: Use FTS5 wildcards for flexible search

• search_term: 'Memory/*' - All memory notes
• search_term: 'Blog/Cycling*' - All cycling blog notes
• search_term: 'Draft*' - Any note starting with Draft

4. Encryption Best Practices:

• Use auto_encrypt: true to automatically detect sensitive data
• Manually encrypt with encrypt_input: true for known sensitive content
• Encrypted content is automatically decrypted on get/search

5. Session Continuity:

• At session start: action: 'search', search_term: 'Memory/Session/*'
• At session end: Save progress with action: 'save', title: 'Memory/Session/{task}-{date}'

6. File Backup Before Deletion:

• Always save file to notes before deletion
• Use: title: 'Deleted/{filepath}-{date}', input_content: '{path}', input_content_is_file: true

OUTPUT STRUCTURE: Save/Update: 'Note saved successfully with ID: {id}' Get: Full note with title, timestamps, input, output List: Array of notes with IDs, titles, modified dates Search: Full-text results with content previews (500 char) Delete: 'Note {id} deleted successfully'

EXAMPLES:

Save code snapshot:

{
  "action": "save",
  "title": "Code/utils.py/Original-2025-01-25",
  "input_content": "/path/to/utils.py",
  "input_content_is_file": true
}

Save session with encryption:

{
  "action": "save",
  "title": "Memory/Session/Task-2025-01-25",
  "input_content": "USER: Implement feature",
  "output_content": "AI: Completed",
  "auto_encrypt": true
}

Search notes:

{
  "action": "search",
  "search_term": "Memory/*",
  "limit": 10
}

Fetch URL content and convert HTML to Markdown. Extracts main content area and outputs clean markdown format. Supports file output.

Check update safety and get backup instructions before updating Pomera. IMPORTANT: In portable mode, npm/pip updates WILL DELETE user data. Always call this with action='check' before initiating any update.

Semantic diff and merge tool for structured data (JSON/YAML/ENV/TOML). Actions: compare_2way (compare before vs after), compare_3way (3-way merge with base/yours/theirs). Format-aware: ignores formatting, focuses on semantic changes. Supports JSON5/JSONC, auto-repair, case-insensitive mode, order-independent arrays, schema validation, and Notes integration.

Specialized text tools for uncommon tasks. Actions: extract (regex/email/URL/IP/phone/date extraction from text), escape (escape/unescape strings: JSON/HTML/URL/XML), markdown (strip formatting, extract links/headers, table conversion/formatting), url_parse (parse URL into components: scheme, host, path, query, fragment), translate (Morse code/binary text encoding/decoding), cron (parse/explain cron expressions, calculate next runs), email_header (analyze email headers: routing, SPF/DKIM, delays).

System operations. Actions: diagnose (check MCP config, database paths, API keys, GUI availability, performance metrics with per-tool latency p50/p95/p99, error rates), launch_gui (launch Pomera GUI application in separate process).

Text manipulation tools. Actions: case (transform case: sentence/lower/upper/title), lines (line manipulation: dedup, remove empty, add/remove numbers, reverse, shuffle), whitespace (trim, remove extra spaces, tabs↔spaces, normalize endings), sort (sort lines numerically or alphabetically), wrap (wrap text to specified width). All actions support file input/output via text_is_file and output_to_file params.

Search the web using multiple engines. Engines: tavily (AI-optimized, recommended), exa (neural AI search, fast/deep modes), google (100/day free), brave (2000/month free), duckduckgo (free, no key), serpapi (100 total free), serper (2500 total free).

TAVILY SEARCH DEPTH OPTIONS:

• basic (default): 1 API credit, balanced relevance/speed, single NLP summary per URL
• advanced: 2 API credits, highest relevance, multiple semantic snippets per source

WHEN TO USE ADVANCED SEARCH: Use search_depth: 'advanced' for:

• Complex research queries requiring high precision
• RAG (Retrieval-Augmented Generation) applications
• Specialized or technical topic searches
• When you need multiple relevant excerpts from each source
• Deep-dive research where accuracy outweighs speed/cost

WHEN TO USE BASIC SEARCH: Use search_depth: 'basic' (default) for:

• General web searches and quick lookups
• Simple factual queries
• Cost-conscious searches (half the credits)
• When speed is more important than depth

COST CONSIDERATION: Advanced search uses 2x the API credits. Use sparingly for complex queries where precision matters most.

EXA AI NEURAL SEARCH (Recommended for AI agents): Exa uses neural search built specifically for AI, providing higher relevance than traditional search.

EXA SEARCH TYPE OPTIONS:

• auto (default): Balanced relevance and speed
• fast: Fastest, basic keyword matching
• neural: Deepest semantic understanding, highest relevance

EXA CATEGORIES (specialized indexes):

• general (default): General web search
• news: News articles
• research paper: Academic papers, arxiv, etc.
• company: Company information
• tweet: Twitter/X posts

EXA CONTENT OPTIONS:

• exa_content_type: 'highlights' (token efficient, default) or 'text' (full webpage)
• exa_max_characters: Max characters to return (100-20000, default 2000)

EXA FRESHNESS:

• exa_max_age_hours: Content age limit. 0=livecrawl (real-time), 24=daily, -1=cache only (default)

WHEN TO USE EXA:

• For AI agent workflows requiring high semantic relevance
• Academic research (use category='research paper')
• News monitoring (use category='news' with max_age_hours=24)
• When you need specific phrase matching (use exa_include_text filter)