Skeet

https://skeet.build/docs
Admin
Skeet enhances developer workflows by connecting AI-powered applications with various tools and data...
Tokens:13,994
Snippets:162
Trust Score:5.8
Update:1 year ago
Show doc for...
Tokens:
Raw
### Example Prompt: Get OpenSearch Index Mapping

Source: https://skeet.build/docs/integrations/opensearch

An example prompt to retrieve the schema information (mapping) for a specific OpenSearch index.

```COMMAND
Get OpenSearch mapping for index: users
```

--------------------------------

### Example Prompt: List OpenSearch Indices

Source: https://skeet.build/docs/integrations/opensearch

An example prompt to list OpenSearch indices matching a specific pattern from the last week.

```COMMAND
List OpenSearch indices matching pattern: logs-* from last week
```

--------------------------------

### Example Prompt: Search OpenSearch Index

Source: https://skeet.build/docs/integrations/opensearch

An example prompt to search a specific OpenSearch index for a name matching "John".

```COMMAND
Search OpenSearch index "users" for name matching "John"
```

--------------------------------

### Fetch Sentry Issues Example Prompt

Source: https://skeet.build/docs/integrations/sentry

An example prompt to retrieve Sentry issues from your connected account.

```Shell
Fetch me my Sentry issues
```

--------------------------------

### Example Prompt for Multi-Agent Code Generation with Sequential Thinking

Source: https://skeet.build/docs/integrations/sequentialthinking

This example illustrates how Sequential Thinking guides an AI through a multi-step process for developing a production-ready React component, from planning and research to coding and review, using an MCP server. It shows the iterative thought process through 'Thought' steps.

```Text
Prompt:
Use Sequential Thinking MCP server to first plan, then code, and finally review a React component
that fetches and displays real-time cryptocurrency prices from a WebSocket API. The final code
should be production-ready and secure.

Output:
Thought 1 (Plan): Okay, planning the component structure. Will use functional components with
Hooks (useState, useEffect). State needed for price data, connection status, and errors. Will
need a WebSocket connection handler utility.
Thought 2 (Research): Searching for reliable public WebSocket APIs for crypto prices... Found
options A and B. Option A seems more stable and has better documentation.
Thought 3 (Code - Component): Implementing React component structure as planned...
Thought 4 (Code - WebSocket): Writing WebSocket connection utility...
Thought 5 (Review): Reviewing component code... Found potential unhandled error state in WebSocket
disconnect. Adding error handling.
Thought 6 (Final): Component planned, coded with WebSocket integration, and reviewed for basic
error handling. Ready for integration.
```

--------------------------------

### Example Prompt to Post Message to Slack Channel

Source: https://skeet.build/docs/integrations/slack

This example demonstrates how to instruct the AI to post a specific message to a designated Slack channel. It shows a common use case for AI-driven communication.

```Natural Language Command
Post a message to #general saying "Hello team, this is a message from my AI assistant"
```

--------------------------------

### Install Ngrok and Create Basic TCP Tunnel

Source: https://skeet.build/docs/use-cases/working-with-local-databases

Instructions to install Ngrok using Homebrew and create a basic TCP tunnel for a local service, typically a database like PostgreSQL, on port 5432. This command exposes the local port to the internet via Ngrok for remote access.

```Shell
# Install ngrok
brew install ngrok

# Create tunnel for PostgreSQL
ngrok tcp 5432
```

--------------------------------

### Install npx Globally

Source: https://skeet.build/docs/apps/claude

Installs `npx` globally using npm if it is not already present on your system. This ensures `npx` is available for command-line execution.

```Shell
npm install -g npx
```

--------------------------------

### Overview of Available Skeet Integrations

Source: https://skeet.build/docs/quickstart

A comprehensive list of various applications and services that can be integrated with Skeet, allowing the AI to access and work with data from these platforms through OAuth. Each integration provides specific functionalities to enhance the AI's capabilities.

```APIDOC
Integrations:
  - Sequential Thinking: Enable dynamic and reflective problem-solving through structured thinking steps.
  - Memory: Access your Memory directly in your workflow.
  - Linear: Get issue details, create issues, add updates to issues, and more.
  - Github: Access your repositories, PRs, and issues directly in your workflow.
  - Slack: Send updates to your team in Slack about issues and PRs.
  - Jira: Access your Jira issues and projects directly in your workflow.
  - Postgres: Access your Postgres databases directly in your workflow.
  - Notion: Access your Notion databases directly in your workflow.
  - MySQL: Access your MySQL databases directly in your workflow.
  - Sentry: Access your Sentry issues and projects directly in your workflow.
  - Figma: Access your Figma files and designs directly in your workflow.
  - Redis: Access your Redis databases directly in your workflow.
  - OpenSearch: Access your OpenSearch databases directly in your workflow.
```

--------------------------------

### Configure MCP Service with SSE using mcp.json

Source: https://skeet.build/docs/apps/mcp-stdio

This configuration example demonstrates how to set up an MCP service to use Server-Sent Events (SSE) transport via Standard Input/Output (stdio) using the `supergateway` package. It defines an MCP server named `skeet.build` that executes a Node.js command (`npx`) to start the gateway with a specified SSE endpoint.

```JSON
{
  "mcpServers": {
    "skeet.build": {
      "command": "npx",
      "args": [
        "-y",
        "@skeetbuild/gateway",
        "--sse",
        "https://skeet.sh/ot/YOUR_SKEET_MCP_KEY"
      ]
    }
  }
}
```

--------------------------------

### Start Local PostgreSQL Server using Homebrew

Source: https://skeet.build/docs/use-cases/working-with-local-databases

Command to start or ensure the PostgreSQL database server is running locally on its default port (5432) using Homebrew services. This is a prerequisite step for connecting to the database via tunnels for remote access.

```Shell
# Ensure PostgreSQL is running on default port 5432
brew services start postgresql
```

--------------------------------

### Searching and Querying Memories (JSON Example)

Source: https://skeet.build/docs/integrations/memory

Provides an example of a JSON payload used to search for specific memories, such as high-priority tasks, based on memory type and keywords, with an option for limiting results.

```JSON
{
  "type": "Task",
  "keyword": "high priority AI integration",
  "topResults": 5
}
```

--------------------------------

### Verify Skeet MCP Connection via AI Command

Source: https://skeet.build/docs/quickstart

After configuring the Skeet MCP key, verify the connection by instructing the AI to list available integrations. This command checks if the AI can successfully communicate with the Skeet MCP server and should result in a welcome message and a list of integrations.

```Natural Language
List my skeet integrations
```

--------------------------------

### Example Prompt: Create Linear Issue via AI

Source: https://skeet.build/docs/integrations/linear

An example natural language prompt to instruct the AI to create a new Linear issue for a bug found in a specific file.

```COMMAND
Create a new Linear issue about a bug I found in the page.tsx file.
```

--------------------------------

### Create New Notion Page Prompt

Source: https://skeet.build/docs/integrations/notion

An example natural language prompt to instruct the AI to create a new Notion page with a specified title and initial content. This demonstrates creating a page directly from a natural language command.

```Prompt
Create a new Notion page titled "Project Ideas" with a list of my brainstormed ideas
```

--------------------------------

### Verify npx Installation

Source: https://skeet.build/docs/apps/claude

Checks if `npx` is installed on your system. `npx` is a tool for executing Node.js package binaries, often used for one-off commands.

```Shell
npx --version
```

--------------------------------

### Search Sentry Issues Example Prompt

Source: https://skeet.build/docs/integrations/sentry

An example prompt to search for unresolved error issues within a specific Sentry organization.

```Shell
Search for unresolved error issues in my 'acme-corp' Sentry organization
```

--------------------------------

### Search Notion Workspace for Content Prompt

Source: https://skeet.build/docs/integrations/notion

An example natural language prompt to search your Notion workspace for specific content, such as a project roadmap. This demonstrates how to initiate a search operation through the AI interface.

```Prompt
Search my Notion workspace for "project roadmap"
```

--------------------------------

### Creating and Relating Memories (JSON Examples)

Source: https://skeet.build/docs/integrations/memory

Illustrates how to create a new project memory, add a related task memory, and establish a relationship between them using JSON payloads, demonstrating core memory management operations.

```JSON
{
  "type": "Project",
  "title": "AI Integration Initiative",
  "content": "Project to integrate AI capabilities into our platform",
  "metadata": {
    "startDate": "2024-03-20",
    "priority": "high"
  }
}

// Create related task
{
  "type": "Task",
  "title": "Setup API Endpoints",
  "content": "Create necessary API endpoints for AI integration",
  "status": "pending",
  "dueDate": 1711238400000
}

// Create relationship
{
  "fromId": "project-123",
  "toId": "task-456",
  "type": "CONTAINS",
  "properties": {
    "order": 1
  }
}
```

--------------------------------

### OpenSearch Match Query Example

Source: https://skeet.build/docs/integrations/opensearch

A common OpenSearch query pattern demonstrating a basic match query on a field with a specific value.

```JSON
{
  "match": {
    "field": "value"
  }
}
```

--------------------------------

### Search Jira Issues using JQL with AI

Source: https://skeet.build/docs/integrations/jira

This snippet illustrates how an AI can perform powerful searches in Jira using JQL. It provides an example natural language prompt and the `jira_jql_search` tool's parameters, including the JQL query string, max results, fields to return, and expansion options. Common JQL examples are also provided.

```Jira AI Prompt
Search Jira for all high priority bugs in project PROJ
```

```APIDOC
jira_jql_search tool parameters:
  jql: JQL query string
  maxResults: Maximum results to fetch
  fields: List of fields to return for each issue
  expand: Additional info to include in the response
```

```JQL
project = PROJ AND priority = High AND issuetype = Bug
assignee = currentUser() AND status != Resolved AND summary ~ "authentication"
```

--------------------------------

### AI Prompt to Search GitHub Issues

Source: https://skeet.build/docs/integrations/github

An example of a natural language prompt to instruct the AI to search for GitHub issues based on specific criteria like state and labels.

```Prompt
Find all open issues with "bug" label in skeet/skeet repository
```

--------------------------------

### Example PostgreSQL DSN String for Ngrok Tunnel

Source: https://skeet.build/docs/use-cases/working-with-local-databases

An example Data Source Name (DSN) string format for connecting to a PostgreSQL database that is exposed through an Ngrok TCP tunnel. This string is used to configure database connections in services like Skeet, requiring placeholders for credentials, Ngrok host, port, and database name.

```SQL
postgresql://username:password@X.tcp.ngrok.io:XXXXX/dbname
```

--------------------------------

### Cursor MCP Configuration

Source: https://skeet.build/docs/quickstart

This JSON snippet shows the structure for configuring Skeet MCP servers within Cursor's global `mcp.json` file. It defines a server entry for 'skeet.build' with its corresponding URL, which includes the user's Skeet MCP key. This configuration allows Cursor to connect to the Skeet Model Context Protocol server.

```JSON
{
  "mcpServers": {
    "skeet.build": {
      "url": "https://skeet.sh/ot/YOUR_SKEET_MCP_KEY"
    }
  }
}
```

--------------------------------

### OpenSearch List Indices Tool Parameters

Source: https://skeet.build/docs/integrations/opensearch

Parameters for the `opensearch_list_indices` AI tool used to list OpenSearch indices, including pattern matching, pagination start, and size.

```APIDOC
{
  "pattern": "Pattern to match indices (e.g., logs-*)",
  "from": "Starting position for pagination",
  "size": "Number of indices to return"
}
```

--------------------------------

### Configure Skeet MCP Server in AI Tools

Source: https://skeet.build/docs/quickstart

Instructions for configuring Skeet MCP servers in AI tools like Windsurf and Claude by modifying their respective configuration files. This involves adding a JSON structure that specifies the MCP server details, including the command and arguments for the Skeet gateway. The configuration should be treated as sensitive information and never shared or committed to version control.

```JSON
{
  "mcpServers": {
    "skeet.build": {
      "command": "npx",
      "args": [
        "-y",
        "@skeetbuild/gateway",
        "--sse",
        "https://skeet.sh/ot/YOUR_SKEET_MCP_KEY"
      ]
    }
  }
}
```

--------------------------------

### AI Prompt to Implement Figma Design

Source: https://skeet.build/docs/integrations/figma

This example prompt demonstrates how to instruct an AI to implement a specific Figma design. It includes the Figma design URL and specifies the target file for implementation, showcasing how to integrate design tasks into an AI workflow.

```COMMAND
Implement this Figma design: https://www.figma.com/design/bxxxxxx/Buoy?node-id=11-0000
on the @page.tsx file
```

--------------------------------

### AI Prompt to Create GitHub Issue

Source: https://skeet.build/docs/integrations/github

An example of a natural language prompt used to instruct the AI to create a new issue in a specified GitHub repository.

```Prompt
Create a new issue in the skeet/skeet repository about a bug I found in the page.tsx file.
```

--------------------------------

### Create GitHub Issue via Cursor AI

Source: https://skeet.build/docs/apps/cursor

Example AI prompt to create a new GitHub issue in a specified repository with a given title and body.

```AI Prompt
Create a GitHub issue in owner/repo with title "Fix navigation bug in header" and body "The dropdown menu in the navigation header doesn't close when clicking outside."
```

--------------------------------

### AI Prompt to Update GitHub Issue

Source: https://skeet.build/docs/integrations/github

An example of a natural language prompt to instruct the AI to update an existing GitHub issue, including changing its title and adding a label.

```Prompt
Update GitHub issue #42 in skeet/skeet repository to change the title to "Fix mobile navigation bug" and add the "mobile" label
```

--------------------------------

### Create Jira Issue via Cursor AI

Source: https://skeet.build/docs/apps/cursor

Example AI prompt to create a new Jira issue in a specified project with a given title and type.

```AI Prompt
Create a Jira issue in project KEY with title "Refactor authentication service" and type Task
```

--------------------------------

### Create GitHub Issue via AI Prompt

Source: https://skeet.build/docs/apps/windsurf

This example demonstrates how to create a new GitHub issue in a specified owner/repository using an AI prompt. You can define the issue's title and body directly within the command.

```AI Prompt
Create a GitHub issue in owner/repo with title "Fix navigation bug in header" and body "The dropdown menu in the navigation header doesn't close when clicking outside."
```

--------------------------------

### PostgreSQL Get Connection Status Tool

Source: https://skeet.build/docs/integrations/postgres

This API documentation describes the `postgres_get_connection_status` tool, which the AI uses to verify the database connection. This tool does not require any input parameters.

```APIDOC
postgres_get_connection_status:
  (no parameters required)
```

--------------------------------

### Create Jira Task via Copilot

Source: https://skeet.build/docs/apps/github-copilot

This example shows how to create a Jira task using GitHub Copilot. The prompt includes the project key and the task title, enabling quick task creation for Jira-managed projects without leaving the VS Code environment.

```plaintext
Create a Jira task in project KEY titled "Refactor authentication"
```

--------------------------------

### Create Linear Issue via Cursor AI

Source: https://skeet.build/docs/apps/cursor

Example AI prompt to create a new Linear issue with a specified title and priority.

```AI Prompt
Create a Linear issue with title "Implement user profile page" and priority high
```

--------------------------------

### Get GitHub Repository Information

Source: https://skeet.build/docs/integrations/github

Retrieve information about a GitHub repository using the `github_get_repo` tool. This tool requires the repository owner and name as parameters.

```Natural Language
Get information about the skeet/skeet repository
```

```APIDOC
{
  "owner": "Repository owner",
  "repo": "Repository name"
}
```

--------------------------------

### Get GitHub Pull Request Details

Source: https://skeet.build/docs/integrations/github

Get detailed information about a specific pull request using the `github_get_pull_request` tool. This tool requires the repository owner, repository name, and pull request number as parameters.

```Natural Language
Get details of pull request #45 in skeet/skeet repository
```

```APIDOC
{
  "owner": "Repository owner",
  "repo": "Repository name",
  "pull_number": "Pull request number"
}
```

--------------------------------

### Update Existing Notion Page Prompt

Source: https://skeet.build/docs/integrations/notion

An example natural language prompt to instruct the AI to update an existing Notion page by adding new content. This demonstrates how to modify a page's content through a natural language command.

```Prompt
Update my "Weekly Goals" Notion page to add a new goal about completing the API documentation
```

--------------------------------

### OpenSearch Get Index Mapping Tool Parameters

Source: https://skeet.build/docs/integrations/opensearch

Parameters for the `opensearch_get_index_mapping` AI tool used to retrieve schema information for an OpenSearch index.

```APIDOC
{
  "index": "Name of the index to get mapping for"
}
```

--------------------------------

### Search Jira Issues with AI Prompt

Source: https://skeet.build/docs/integrations/jira

This example demonstrates how to use a natural language prompt to search for specific Jira issues based on criteria like priority and project. Users can find relevant information without leaving the AI interface.

```Natural Language Prompt
Search Jira for all high priority bugs in project PROJ
```

--------------------------------

### Create GitHub Issue via Copilot

Source: https://skeet.build/docs/apps/github-copilot

This example demonstrates how to use GitHub Copilot to create a new GitHub issue. The prompt specifies the repository owner, repository name, issue title, and the body content, streamlining issue creation directly from the editor.

```plaintext
Create a GitHub issue in owner/repo titled "Fix navigation bug" with body "Dropdown menu doesn't close when clicking outside."
```

--------------------------------

### Get PostgreSQL Schema and Build User Model

Source: https://skeet.build/docs/integrations/postgres

This command prompt instructs the AI to retrieve the schema for a specific table (e.g., 'Users') from your PostgreSQL database and then use that schema to build a corresponding data model.

```COMMAND
Get the the Schema in postgres for the Users Table then build the Users Model
```

--------------------------------

### Create Jira Task via AI Prompt

Source: https://skeet.build/docs/apps/windsurf

This example shows how to create a new Jira issue of a specific type (e.g., 'Task') within a designated project using an AI prompt. The command allows you to set the issue's title.

```AI Prompt
Create a Jira issue in project KEY with title "Refactor authentication service" and type Task
```

--------------------------------

### TypeScript: Implementing Exponential Backoff for Token Refresh

Source: https://skeet.build/docs/use-cases/deep-research

Provides a TypeScript example for a `refreshToken` function that incorporates exponential backoff and retry logic to handle rate limiting (HTTP 429) and other retryable errors during API calls, preventing cascading authentication failures and improving system resilience.

```typescript
// auth-service.ts
async function refreshToken(token: string): Promise<AuthResponse> {
  const maxRetries = 3;
  let retryCount = 0;

  while (retryCount < maxRetries) {
    try {
      const response = await fetch(AUTH_ENDPOINT, {
        method: 'POST',
        headers: { 'Authorization': `Bearer ${token}` }
      });

      if (response.status === 429) {
        // Calculate backoff time: 2^retry * 100ms + random jitter
        const backoffMs = (Math.pow(2, retryCount) * 100) +
                          (Math.random() * 100);
        await new Promise(resolve => setTimeout(resolve, backoffMs));
        retryCount++;
        continue;
      }

      return await response.json();
    } catch (error) {
      if (isRetryableError(error) && retryCount < maxRetries) {
        retryCount++;
        continue;
      }
      throw error;
    }
  }

  throw new Error('Max retries exceeded for token refresh');
}
```

--------------------------------

### Figma Get Data Tool Parameters

Source: https://skeet.build/docs/integrations/figma

This API documentation outlines the parameters for the `figma_get_data` tool. It specifies the required `fileKey` for accessing a Figma file, an optional `nodeId` for specific elements, and `depth` for controlling data retrieval granularity.

```APIDOC
{
  "fileKey": "figma_file_key",
  "nodeId": "optional_node_id",
  "depth": 1
}
```

--------------------------------

### Getting Project Issues in Sentry

Source: https://skeet.build/docs/integrations/sentry

Demonstrates how to list issues for a specific project in Sentry using a natural language prompt and provides the JSON schema for the `sentry_get_issues` tool, including parameters like organization, project, query, and sorting options.

```Natural Language
Show me issues from the 'backend-api' project in 'acme-corp' organization
```

```APIDOC
{
  "organization": "Organization slug",
  "project": "Project slug",
  "query": "Search query to filter issues",
  "statsPeriod": "Time period to get stats for (e.g., '24h', '14d')",
  "shortIdLookup": "Whether to treat the query as a short ID lookup",
  "sort": "Sort order (e.g., 'date', 'new', 'priority')",
  "cursor": "Pagination cursor"
}
```

--------------------------------

### Jira Create Issue Tool API Parameters

Source: https://skeet.build/docs/integrations/jira

This APIDOC snippet outlines the JSON parameters for the `jira_create_issue` tool. It details required fields like project, summary, and issue type, along with optional parameters such as description, assignee, and priority, guiding developers on how to structure their API calls.

```APIDOC
{
  "project": "Project key where the issue will be created",
  "summary": "Issue summary/title",
  "description": "Detailed description of the issue",
  "issuetype": "Type of issue (e.g., 'Bug', 'Task', 'Story')",
  "assignee": "ID of the user to assign the issue to",
  "priority": "Priority ID of the issue"
}
```

--------------------------------

### Get GitHub Issue Details

Source: https://skeet.build/docs/integrations/github

Retrieve detailed information about a specific GitHub issue using the `github_get_issue` tool. This tool requires the repository owner, repository name, and issue number as parameters.

```Natural Language
Show me the details of issue #123 in skeet/skeet repository
```

```APIDOC
{
  "owner": "Repository owner",
  "repo": "Repository name",
  "issue_number": "Issue number"
}
```

--------------------------------

### Getting Sentry Issue Details

Source: https://skeet.build/docs/integrations/sentry

Illustrates how to retrieve detailed information for a specific Sentry issue using a natural language prompt and provides the JSON schema for the `sentry_get_issue` tool, requiring an issue ID.

```Natural Language
Get details for Sentry issue with ID '1234567'
```

```APIDOC
{
  "issueId": "Issue ID"
}
```

--------------------------------

### Verify Skeet Jira Integration via CLI

Source: https://skeet.build/docs/integrations/jira

This command-line snippet allows users to verify that their Skeet AI is successfully connected to their Jira account by listing all active Skeet integrations. It's a crucial step after initial authentication to ensure proper setup.

```CLI
List my skeet integrations
```

--------------------------------

### Getting Sentry Event Details

Source: https://skeet.build/docs/integrations/sentry

Shows how to retrieve detailed information about a specific Sentry event using a natural language prompt and provides the JSON schema for the `sentry_get_event` tool, including parameters for organization, issue ID, event ID, and environment.

```Natural Language
Show me the latest event for issue '1234567' in the 'acme-corp' organization
```

```APIDOC
{
  "organization": "Organization slug",
  "issueId": "Issue ID",
  "eventId": "Event ID or one of 'latest', 'oldest', or 'recommended'",
  "environment": "Optional environment name to filter by"
}
```

--------------------------------

### Get Detailed Information for a Linear Issue (AI Tool: linear_get_issue)

Source: https://skeet.build/docs/integrations/linear

This snippet shows an AI command to fetch detailed information for a specific Linear issue. It also provides the API documentation for the linear_get_issue tool, specifying the required id parameter for identifying the issue.

```Shell
Show me details for Linear issue DP-456
```

```APIDOC
linear_get_issue:
  id: The ID of the issue to retrieve (e.g., 'DP-456')
```

--------------------------------

### Skeet MCP Generated GitHub Issue Summary

Source: https://skeet.build/docs/use-cases/ticket-enrichment

An example of a structured summary automatically generated by Skeet MCP when enriching a GitHub issue. It includes key details like the reported issue, recent code changes, suggested action items, and relevant team member mentions.

```markdown
### Issue Summary
- **Reported Issue:** Users encountering login failures.
- **Recent Changes:** PR #234 modified authentication logic.

### Action Items
- [ ] Verify changes from PR #234
- [ ] Reproduce issue

### @mentions
@alice (authentication expert), @bob (recent PR author)

```

--------------------------------

### Create GitHub Repository

Source: https://skeet.build/docs/integrations/github

Create a new GitHub repository using the `github_create_repository` tool. This tool allows specifying the owner, repository name, description, privacy setting, and whether to auto-initialize with a README.

```Natural Language
Create a new GitHub repository named "my-project" with description "A new awesome project"
```

```APIDOC
{
  "owner": "Repository owner (user or organization)",
  "repo": "Repository name",
  "description": "Repository description",
  "private": "Whether the repository should be private",
  "autoInit": "Initialize with README.md"
}
```

--------------------------------

### Get Slack Message Thread Replies

Source: https://skeet.build/docs/integrations/slack

This snippet demonstrates how to fetch all replies within a specific Slack message thread using a natural language command. The API schema for the `slack_get_thread_replies` tool requires the channel ID and the parent message's timestamp. It supports limiting results, pagination, and time-based filtering.

```Natural Language
Show me all replies to the message with timestamp 1698347622.000700 in #support
```

```APIDOC
{
  "channel": "Channel ID containing the thread",
  "ts": "Timestamp of the parent message",
  "limit": "Maximum number of replies to return (default: 100)",
  "cursor": "Pagination cursor for fetching next page of results",
  "oldest": "Start of time range to include replies (timestamp)",
  "latest": "End of time range to include replies (timestamp)",
  "inclusive": "Include replies with timestamps matching oldest/latest bounds"
}
```

--------------------------------

### Create and Link Project and Task Memories

Source: https://skeet.build/docs/integrations/memory

This prompt demonstrates how to create a new project memory and link multiple task memories to it, establishing dependencies within the knowledge graph.

```Prompt
Create a project memory called "New Website Launch" and connect task memories 
like "Design Homepage," "Setup Analytics," and "Launch Marketing Campaign."
```

--------------------------------

### Configure Zed's settings.json for Skeet MCP Server

Source: https://skeet.build/docs/apps/zed

This snippet demonstrates how to add the Skeet MCP server configuration to your Zed `settings.json` file. It specifies the `npx` command to run the `@skeetbuild/gateway` and includes a placeholder for your Skeet MCP key, which is essential for accessing your connected integrations.

```json
{
  "context_servers": {
    "skeet.build": {
      "command": {
        "path": "npx",
        "args": [
          "-y",
          "@skeetbuild/gateway",
          "--sse",
          "https://skeet.sh/ot/YOUR_SKEET_MCP_KEY"
        ],
        "env": null
      },
      "settings": {}
    }
  }
}
```

--------------------------------

### Verify OpenSearch Connection Command

Source: https://skeet.build/docs/integrations/opensearch

Command to list Skeet integrations and verify the OpenSearch connection.

```COMMAND
List my skeet integrations
```

--------------------------------

### Create a New Project Memory

Source: https://skeet.build/docs/integrations/memory

A simple prompt to create a new project memory for a specific initiative within the knowledge graph.

```Prompt
Create a new project memory for our website redesign initiative
```

--------------------------------

### List Skeet Integrations with GitHub Copilot

Source: https://skeet.build/docs/apps/github-copilot

This prompt is used within GitHub Copilot's chat mode to query and display all available Skeet integrations and their current statuses. It helps users verify that their MCP server is correctly set up and that tools are accessible.

```plaintext
List my Skeet integrations
```

--------------------------------

### Configure Global Model Context Protocol (MCP) for Cursor

Source: https://skeet.build/docs/apps/cursor

This configuration snippet demonstrates how to set up a global Model Context Protocol (MCP) server for Cursor. By placing this `mcp.json` file in your home directory's `.cursor` folder, the Skeet MCP server becomes accessible across all your Cursor workspaces. Remember to replace `<YOUR_SKEET_MCP_KEY>` with your actual key from the Skeet dashboard.

```JSON
{
  "mcpServers": {
    "skeet.build": {
      "url": "https://skeet.sh/ot/YOUR_SKEET_MCP_KEY"
    }
  }
}
```

--------------------------------

### List Redis Keys by Pattern Matching

Source: https://skeet.build/docs/integrations/redis

This command lists keys in the Redis database that match a specified pattern, allowing for flexible data retrieval and organization. Use descriptive key patterns for effective data management.

```Natural Language Prompt
List Redis keys matching pattern: user:*
```

--------------------------------

### Verify Skeet GitHub Integration

Source: https://skeet.build/docs/integrations/github

This command verifies your GitHub connection by listing your current Skeet integrations.

```COMMAND
List my skeet integrations
```

--------------------------------

### Verify Skeet Notion Integration Command

Source: https://skeet.build/docs/integrations/notion

This command line prompt verifies that your Skeet integrations are correctly set up, including the Notion connection, after authenticating your Notion account in the Skeet dashboard.

```COMMAND
List my skeet integrations
```

--------------------------------

### Search GitHub Repositories with AI

Source: https://skeet.build/docs/integrations/github

This snippet shows how an AI can search for repositories on GitHub using the `github_search_repositories` tool. It details the query and optional sorting parameters for repository search.

```Natural Language
Find GitHub repositories related to "AI integration"
```

```APIDOC
github_search_repositories tool schema:
{
  "q": "Search query",
  "sort": "Sort field (indexed, best-match)",
  "order": "Sort order (desc, asc)"
}
```

--------------------------------

### Skeet MCP Server Configuration in mcp.json

Source: https://skeet.build/docs/apps/github-copilot

This JSON snippet illustrates the structure for configuring Skeet MCP servers within the 'mcp.json' file, typically located in user settings. It defines a server named 'skeet.build' with its corresponding URL, which includes a placeholder for the user's unique Skeet MCP key. This configuration allows VS Code to connect to the specified MCP server.

```json
{
  "mcp": {
    "servers": {
      "skeet.build": {
        "url": "https://skeet.sh/ot/YOUR_SKEET_MCP_KEY"
      }
    }
  }
}
```

--------------------------------

### Create GitHub Issue with AI Command

Source: https://skeet.build/docs/apps/zed

Demonstrates how to create a GitHub issue in a specified repository with a title and body using a natural language command for the AI assistant.

```AI Command
Create a GitHub issue in owner/repo with title "Fix navigation bug in header" and body "The dropdown menu in the navigation header doesn't close when clicking outside."
```

--------------------------------

### Applying Sequential Thinking for User Authentication Implementation

Source: https://skeet.build/docs/integrations/sequentialthinking

This snippet demonstrates a basic application of Sequential Thinking to systematically break down the implementation of user authentication into manageable steps. It outlines the thought process from defining requirements to planning the testing strategy.

```text
Think through the steps needed to implement user authentication:
1. Define requirements
2. Design data model
3. Plan API endpoints
4. Consider security measures
5. Outline testing strategy

```

--------------------------------

### List Sentry Projects

Source: https://skeet.build/docs/integrations/sentry

This command displays all Sentry projects available to the authenticated user.

```Shell
Show me all my Sentry projects
```

--------------------------------

### Execute Basic PostgreSQL Query

Source: https://skeet.build/docs/integrations/postgres

This command prompt demonstrates how to execute a direct SQL query against your PostgreSQL database through the AI interface. It shows a simple SELECT statement to retrieve data.

```COMMAND
Execute a PostgreSQL query: SELECT * FROM users LIMIT 10
```

--------------------------------

### Memory Integration API Parameters

Source: https://skeet.build/docs/integrations/memory

Details the various parameters accepted by the Memory integration tools, including their types and descriptions, for operations like creating, updating, and querying specific memories.

```APIDOC
type: string (The type of memory: Conversation, Topic, Project, Task, Issue, Config, Finance, Todo)
content: string (The main content of the memory)
title: string (Optional title for the memory)
metadata: object (Additional metadata for the memory)
id: string (Identifier for retrieving or updating specific memories)
status: string (Status information for tasks or issues)
dueDate: number (Timestamp for due dates on tasks or todos)
```

--------------------------------

### Sequential Thinking MCP Server Investigation Prompt and Output

Source: https://skeet.build/docs/use-cases/deep-research

Demonstrates the step-by-step thought process of a Sequential Thinking MCP server in diagnosing an intermittent authentication failure, from defining the goal to recommending solutions for rate limiting and load balancer issues.

```Plaintext
Prompt:
Use Sequential Thinking MCP server to investigate why our app's authentication is failing intermittently in production. Research possible causes, identify patterns in error logs, and determine if it's related to our recent API integration or infrastructure changes.

Output:
Thought 1 (Define Goal): Research intermittent authentication failures in production. Need to examine logs, recent changes, and identify patterns.

Thought 2 (Research - Error Logs): Analyzing production logs... Found repeated 401 errors with consistent pattern: occurring during peak traffic hours (11am-1pm), primarily affecting users with JWT tokens older than 30 minutes.

Thought 3 (Research - Recent Changes): Examining recent deployments... Identified two potential factors: 1) API rate limiting added to auth provider two weeks ago, 2) Load balancer configuration changed last week.

Thought 4 (Investigation - Auth Flow): Tracing authentication flow... Discovered an edge case where token refresh calls don't properly handle 429 responses from auth provider, causing cascading auth failures during high traffic.

Thought 5 (Investigation - Infrastructure): Checking load balancer configuration... Found connection pooling settings causing requests to be dropped when connections exceed threshold, which coincides with peak traffic periods.

Thought 6 (Root Cause Analysis): Primary issue: Auth service not implementing proper backoff/retry logic when receiving rate limit responses. Secondary issue: Load balancer connection pool size insufficient for peak traffic.

Thought 7 (Solution Recommendations):
1. Implement exponential backoff for token refresh operations
2. Add proper error handling for 429 responses
3. Increase load balancer connection pool limits by 40%
4. Add monitoring alert for auth failure rate exceeding 0.5%

Thought 8 (Documentation): Created incident analysis document highlighting root causes and solution path. Added code example showing proper implementation:
```

--------------------------------

### Configure Claude Desktop with Skeet MCP Server

Source: https://skeet.build/docs/apps/claude

Adds the Skeet MCP server configuration to Claude Desktop's `claude_desktop_config.json` file. This configuration specifies how Claude should connect to and use your Skeet gateway, replacing `YOUR_SKEET_MCP_KEY` with your actual key.

```JSON
{
  "mcpServers": {
    "skeet.build": {
      "command": "npx",
      "args": [
        "-y",
        "@skeetbuild/gateway",
        "--sse",
        "https://skeet.sh/ot/YOUR_SKEET_MCP_KEY"
      ]
    }
  }
}
```

--------------------------------

### Configure Project-Specific Model Context Protocol (MCP) for Cursor

Source: https://skeet.build/docs/apps/cursor

This configuration snippet illustrates how to set up a project-specific Model Context Protocol (MCP) server for Cursor. By placing this `mcp.json` file within your project's `.cursor` folder, the Skeet MCP server will only be active when you are working within that specific project directory. Ensure to replace `<YOUR_SKEET_MCP_KEY>` with your actual key from the Skeet dashboard.

```JSON
{
  "mcpServers": {
    "skeet.build": {
      "url": "https://skeet.sh/ot/YOUR_SKEET_MCP_KEY"
    }
  }
}
```

--------------------------------

### Manage Slack Users and Profiles

Source: https://skeet.build/docs/integrations/slack

This snippet shows how to list users in a Slack workspace using a natural language command. It provides the API schema for the `slack_get_users` tool, which allows limiting the number of users, using a pagination cursor, and including locale information. The text mentions `slack_get_user_profile` but only provides parameters for `slack_get_users`.

```Natural Language
List all users in my Slack workspace
```

```APIDOC
{
  "limit": "Maximum number of users to return (default: 100)",
  "cursor": "Pagination cursor for fetching next page of results",
  "include_locale": "Include locale information for users"
}
```

--------------------------------

### Search GitHub Code with AI

Source: https://skeet.build/docs/integrations/github

This snippet demonstrates how an AI can search for code across GitHub repositories using the `github_search_code` tool. It specifies the query and optional sorting parameters.

```Natural Language
Search for code containing "authentication" in skeet repositories
```

```APIDOC
github_search_code tool schema:
{
  "q": "Search query",
  "sort": "Sort field (indexed, best-match)",
  "order": "Sort order (desc, asc)"
}
```

--------------------------------

### Figma Download Images Tool Parameters

Source: https://skeet.build/docs/integrations/figma

This API documentation details the parameters for the `figma_download_images` tool. It requires a `fileKey`, a list of `nodes` (each with `nodeId` and `fileName`), and an optional `localPath` to specify where images should be saved.

```APIDOC
{
  "fileKey": "figma_file_key",
  "nodes": [
    {
      "nodeId": "node_containing_image",
      "fileName": "hero-image.png"
    }
  ],
  "localPath": "path/to/save/images"
}
```

--------------------------------

### PostgreSQL Execute Query Tool Parameters

Source: https://skeet.build/docs/integrations/postgres

This API documentation describes the parameters required by the `postgres_execute_query` tool, which the AI uses to run SQL queries. It includes fields for the SQL string and an optional array for parameterized query values.

```APIDOC
postgres_execute_query:
  sql: The SQL query to execute
  params: Parameters for the query (if using $1, $2, etc.)
```

--------------------------------

### Create GitHub Branches with AI

Source: https://skeet.build/docs/integrations/github

This snippet shows how an AI can create a new branch in a GitHub repository from an existing one using the `github_create_branch` tool. It details the parameters required for branch creation.

```Natural Language
Create a new branch called "feature/auth" from main in skeet/skeet repository
```

```APIDOC
github_create_branch tool schema:
{
  "owner": "Repository owner",
  "repo": "Repository name",
  "branch": "New branch name",
  "from_branch": "Branch to create from"
}
```

--------------------------------

### Create or Update GitHub Files with AI

Source: https://skeet.build/docs/integrations/github

This snippet demonstrates how an AI can create new files or update existing ones in a GitHub repository using the `github_create_or_update_file` tool. It specifies the required parameters for the operation.

```Natural Language
Update README.md in skeet/skeet repository with content "# Skeet\n\nA powerful integration platform for AI"
```

```APIDOC
github_create_or_update_file tool schema:
{
  "owner": "Repository owner",
  "repo": "Repository name",
  "path": "Path to the file in the repository",
  "content": "File content to create or update",
  "message": "Commit message",
  "branch": "Branch name (default: repository's default branch)",
  "sha": "SHA of the file being replaced (required for updating existing file)"
}
```

--------------------------------

### AI Prompt for Basic GitHub Issue Creation

Source: https://skeet.build/docs/integrations/github

A basic natural language prompt to create a new GitHub issue with a title in a specified repository.

```Prompt
Create a new GitHub issue with title "Fix navigation bug" in the skeet/skeet repository
```

--------------------------------

### Notion Create Page Tool API Parameters

Source: https://skeet.build/docs/integrations/notion

Specifies the JSON parameters for the `notion_create_page` tool, used to create new pages in Notion. It allows defining the parent page, page title, and initial content blocks, along with an optional emoji.

```JSON
{
  "parent": {
    "page_id": "Parent page ID"
  },
  "properties": {
    "title": [{
      "text": {
        "content": "Page title"
      }
    }]
  },
  "children": [
    {
      "object": "block",
      "type": "paragraph",
      "paragraph": {
        "rich_text": [{
          "text": {
            "content": "Page content"
          }
        }]
      }
    }
  ],
  "emoji": "📝"
}
```

--------------------------------

### Send Test Message to Slack General Channel

Source: https://skeet.build/docs/integrations/slack

This command sends a 'hello world' test message to the #general channel in Slack. It's used to confirm that the Skeet bot can successfully post messages after being invited to the channel.

```Natural Language Command
send a "hello world" test message to general channel
```

--------------------------------

### Verify PostgreSQL Integration Connection

Source: https://skeet.build/docs/integrations/postgres

This command prompt allows you to verify that your PostgreSQL database is correctly connected and recognized by listing your active Skeet integrations.

```COMMAND
List my skeet integrations
```

--------------------------------

### API Parameters for Listing Slack Channels (slack_list_channels)

Source: https://skeet.build/docs/integrations/slack

Defines the available parameters for the `slack_list_channels` tool, allowing for advanced filtering and pagination when retrieving Slack channel lists. Parameters include limits, cursors, and channel types.

```APIDOC
{
  "limit": "Maximum number of channels to return (default: 100, max: 1000)",
  "cursor": "Pagination cursor for fetching next page of results",
  "exclude_archived": "Exclude archived channels from results",
  "types": "Comma-separated list of channel types to include"
}
```

--------------------------------

### Configure Windsurf MCP with Skeet via mcp.json

Source: https://skeet.build/docs/apps/windsurf

For advanced users, this snippet shows how to manually add the Skeet MCP server configuration to the `mcp_config.json` file. This method requires editing the file directly and restarting Windsurf for changes to take effect. Remember to replace `<YOUR_SKEET_MCP_KEY>` with your actual Skeet MCP key from the dashboard and never share or commit this file to version control.

```JSON
{
  "mcpServers": {
    "skeet.build": {
      "command": "npx",
      "args": [
        "-y",
        "@skeetbuild/gateway",
        "--sse",
        "https://skeet.sh/ot/YOUR_SKEET_MCP_KEY"
      ]
    }
  }
}
```

--------------------------------

### OpenSearch Query Index Tool Parameters

Source: https://skeet.build/docs/integrations/opensearch

Parameters for the `opensearch_query_index` AI tool used to execute search queries on an OpenSearch index, including index name, query object, pagination, and sorting.

```APIDOC
{
  "index": "Name of the index to query",
  "query": "OpenSearch query object",
  "from": "Starting position for pagination",
  "size": "Number of results per page",
  "sort": "Optional sorting criteria"
}
```

--------------------------------

### Search GitHub Users with AI

Source: https://skeet.build/docs/integrations/github

This snippet illustrates how an AI can search for users on GitHub using the `github_search_users` tool. It outlines the query and optional sorting parameters for user search.

```Natural Language
Find GitHub users with "skeet" in their name or bio
```

```APIDOC
github_search_users tool schema:
{
  "q": "Search query",
  "sort": "Sort field (followers, repositories, joined)",
  "order": "Sort order (desc, asc)"
}
```

--------------------------------

### Verify MySQL Connection Status with Skeet

Source: https://skeet.build/docs/integrations/mysql

This command verifies that your AI is connected to Skeet and can list available integrations, including MySQL.

```COMMAND
List my skeet integrations
```

--------------------------------

### Execute Basic MySQL SELECT Query

Source: https://skeet.build/docs/integrations/mysql

This snippet shows how to execute a basic SELECT SQL query directly on your MySQL database through the AI interface.

```SQL
Execute MySQL query: SELECT * FROM users LIMIT 10
```

--------------------------------

### sentry_list_projects Tool Parameters

Source: https://skeet.build/docs/integrations/sentry

Parameters for the `sentry_list_projects` tool, allowing filtering by organization and pagination.

```APIDOC
{
  "cursor": "Pagination cursor for fetching next page of results",
  "organization": "Optional organization slug to filter projects by organization"
}
```

--------------------------------

### Verify Skeet Integrations in Zed Agent Panel

Source: https://skeet.build/docs/apps/zed

After configuring the MCP server, use this prompt within Zed's Agent Panel to list your connected Skeet integrations. A successful response will confirm the connection and display the available tools and their status.

```plaintext
List my Skeet integrations

```

--------------------------------

### Fetch Top 10 Users from MySQL Table

Source: https://skeet.build/docs/integrations/mysql

This prompt demonstrates how to use the AI to fetch the top 10 users from a 'users' table in a MySQL database.

```SQL
Fetch in mysql the top 10 users from the users table
```

--------------------------------

### Verify Skeet Integrations with Cursor AI

Source: https://skeet.build/docs/apps/cursor

Command to ask the Cursor AI assistant to list all connected Skeet integrations and their status, confirming the MCP connection.

```AI Prompt
List my Skeet integrations
```

--------------------------------

### Retrieve Authenticated Jira User and Project Info with AI

Source: https://skeet.build/docs/integrations/jira

This snippet demonstrates how an AI can retrieve information about the currently authenticated Jira user, including available projects, issue types, and workflows. It shows the natural language prompt for the `jira_get_viewer` tool, which requires no parameters.

```Jira AI Prompt
Get my Jira information and available projects
```

```APIDOC
jira_get_viewer tool parameters: (No parameters required)
```

--------------------------------

### Search Jira Users with AI

Source: https://skeet.build/docs/integrations/jira

This snippet shows how an AI can search for Jira users. It includes the natural language prompt and the `jira_search_users` tool's single parameter, which is the query string used to find users.

```Jira AI Prompt
Find Jira user "john.doe"
```

```APIDOC
jira_search_users tool parameters:
  query: Query to search for users
```

--------------------------------

### GitHub Create Issue Tool Parameters

Source: https://skeet.build/docs/integrations/github

Defines the parameters for the `github_create_issue` tool, used by the AI to create new issues in GitHub repositories.

```APIDOC
{
  "owner": "Repository owner (user or organization)",
  "repo": "Repository name",
  "title": "Issue title",
  "body": "Issue body/description",
  "labels": ["List of label names"],
  "assignees": ["List of user logins to assign"],
  "milestone": "Milestone number"
}
```

--------------------------------

### Retrieve Authenticated Linear User Information (AI Tool: linear_get_viewer)

Source: https://skeet.build/docs/integrations/linear

This section demonstrates an AI command to retrieve details about the authenticated Linear user. It notes that the linear_get_viewer tool used for this purpose does not require any input parameters.

```Shell
Get my Linear user information
```

```APIDOC
linear_get_viewer: (No parameters required)
```

--------------------------------

### Search Linear Issues via AI Prompt

Source: https://skeet.build/docs/integrations/linear

A natural language prompt to search for Linear issues based on criteria like priority and team.

```COMMAND
Find all high priority bugs in the Engineering team
```

--------------------------------

### Fetch User Keys from Redis Database

Source: https://skeet.build/docs/integrations/redis

This command demonstrates how to retrieve user-related keys stored in your Redis database. It's a basic query to fetch data based on a general key type.

```Natural Language Prompt
Fetch in redis the users keys
```

--------------------------------

### Retrieve GitHub File Contents with AI

Source: https://skeet.build/docs/integrations/github

This snippet illustrates how an AI can retrieve the contents of a specific file from a GitHub repository using the `github_get_file_contents` tool. It outlines the necessary parameters for file retrieval.

```Natural Language
Show me the content of package.json in skeet/skeet repository
```

```APIDOC
github_get_file_contents tool schema:
{
  "owner": "Repository owner",
  "repo": "Repository name",
  "path": "Path to the file or directory",
  "branch": "Branch name (default: repository's default branch)"
}
```

--------------------------------

### Standardize Backlog Tickets with Skeet MCP

Source: https://skeet.build/docs/use-cases/ticket-enrichment

This use case demonstrates how Skeet MCP can automate backlog refinement by ensuring all tickets in Jira or Linear have complete and uniform formatting. It reduces overhead by providing clear guidance for task execution.

```Prompt
Show me all backlog items for my next sprint in Linear. Standardize each ticket with clear summaries, action items, reproducibility steps, and relevant details.
```

--------------------------------

### Create GitHub Pull Request Reviews

Source: https://skeet.build/docs/integrations/github

Create reviews for pull requests and add review comments using the `github_create_pull_request_review` tool. This tool allows specifying a review body and an event (APPROVE, REQUEST_CHANGES, COMMENT).

```Natural Language
Review pull request #89 in skeet/skeet repository and approve it with comment "LGTM!"
```

```APIDOC
{
  "owner": "Repository owner",
  "repo": "Repository name",
  "pull_number": "Pull request number",
  "body": "Review body",
  "event": "Review event (APPROVE, REQUEST_CHANGES, COMMENT)"
}
```

--------------------------------

### Defining Advanced Memory Relationships (JSON)

Source: https://skeet.build/docs/integrations/memory

Demonstrates how to create a specific dependency relationship between two task memories using a JSON structure, highlighting the `DEPENDS_ON` type and custom properties.

```JSON
{
  "fromId": "task-123",
  "toId": "task-456",
  "type": "DEPENDS_ON",
  "properties": {
    "criticality": "high"
  }
}
```

--------------------------------

### Create Jira Issue with AI Command

Source: https://skeet.build/docs/apps/zed

Demonstrates how to create a Jira issue in a specified project with a title and type using a natural language command for the AI assistant.

```AI Command
Create a Jira issue in project KEY with title "Refactor authentication service" and type Task
```

--------------------------------

### Redis List Keys Tool Parameters

Source: https://skeet.build/docs/integrations/redis

Defines the parameters required for listing keys in Redis using the AI's internal tool. The 'pattern' parameter is used to filter keys.

```JSON
{
  "pattern": "Pattern to match keys (e.g., user:*)"
}
```

--------------------------------

### Query Notion Database with Filters and Sorts via AI Tool

Source: https://skeet.build/docs/integrations/notion

This snippet illustrates how an AI tool can query Notion databases, applying filters and sorts. A natural language request is converted into a `notion_query_database` tool call, showcasing parameters for `database_id`, complex `filter` objects, `sorts`, and `page_size`.

```Natural Language
Show me all tasks in my Projects database with "High" priority
```

```JSON
{
  "database_id": "Database ID",
  "filter": {
    "property": "Priority",
    "select": {
      "equals": "High"
    }
  },
  "sorts": [
    {
      "property": "Due Date",
      "direction": "ascending"
    }
  ],
  "page_size": 10
}
```

--------------------------------

### List Slack Channels in Workspace

Source: https://skeet.build/docs/integrations/slack

This command instructs the AI to list all public channels available in the connected Slack workspace. It's a basic way to retrieve channel information.

```Natural Language Command
List Slack channels in my workspace
```

--------------------------------

### sentry_search_issues Tool Parameters

Source: https://skeet.build/docs/integrations/sentry

Parameters for the `sentry_search_issues` tool, enabling flexible searching, sorting, and pagination of Sentry issues.

```APIDOC
{
  "organization": "Organization slug",
  "project": "Optional project slug to limit search to a specific project",
  "query": "Search query string (e.g., 'is:unresolved', 'level:error', etc.)",
  "statsPeriod": "Time period for stats (e.g., '24h', '14d', '30d')",
  "sort": "Field to sort by (e.g., 'date', 'priority', 'freq')",
  "cursor": "Pagination cursor",
  "limit": "Maximum number of results to return"
}
```

--------------------------------

### Redis Set Value Tool Parameters

Source: https://skeet.build/docs/integrations/redis

Defines the parameters required for setting a value in Redis using the AI's internal tool. These parameters specify the key, the value to store, and an optional expiration time.

```JSON
{
  "key": "Key to store the value under",
  "value": "Value to store",
  "expireSeconds": "Optional expiration time in seconds"
}
```

--------------------------------

### Transition Jira Issue Status with AI

Source: https://skeet.build/docs/integrations/jira

This snippet demonstrates how an AI can transition a Jira issue through its workflow. It shows the natural language prompt and the underlying `jira_transition_issue` tool's required parameters, including the issue key and the specific transition ID. Transition IDs are workflow-dependent and can be found using `jira_get_viewer`.

```Jira AI Prompt
Move Jira issue PROJ-123 to "In Progress" status
```

```APIDOC
jira_transition_issue tool parameters:
  issueKey: Key of the issue to transition (e.g., 'PROJ-123')
  transitionId: ID of the transition to apply
```

--------------------------------

### Test MCP Server Connection in Claude

Source: https://skeet.build/docs/apps/claude

A command to be used within Claude's interface to verify that the Skeet MCP server is correctly connected and its integrations are recognized.

```Shell
Check my skeet integrations
```

--------------------------------

### Searching Sentry Events

Source: https://skeet.build/docs/integrations/sentry

Demonstrates how to search for events across a project or organization in Sentry using a natural language prompt and provides the JSON schema for the `sentry_search_events` tool, allowing filtering by query, environment, and sorting.

```Natural Language
Search for error events in the 'acme-corp' organization containing 'database connection'
```

```APIDOC
{
  "organization": "Organization slug",
  "project": "Optional project slug to limit search to a specific project",
  "query": "Search query string to filter events",
  "environment": "Optional list of environments to filter by",
  "sort": "Field to sort by (e.g., 'timestamp', 'user')",
  "cursor": "Pagination cursor",
  "limit": "Maximum number of results to return"
}
```
Tokens:
Raw