### Quick Start Installation and Setup

Source: https://github.com/klavis-ai/klavis/blob/main/mcp_servers/google_meet/README.md

Instructions for setting up the Google Meet MCP server, including virtual environment creation, dependency installation, and environment variable configuration for port and authentication.

```bash
uv venv
./.venv/Scripts/Activate.ps1   # (PowerShell)  |  source .venv/bin/activate (bash)
uv pip install -r requirements.txt
set GOOGLE_MEET_MCP_SERVER_PORT=5000
set AUTH_DATA={"access_token":"ya29.your_token"}
uv run server.py --stdio  # stdio mode (Claude Desktop)
# OR HTTP/SSE
uv run server.py --port 5000 --log-level INFO
```

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

### Quick Start CLI Commands

Source: https://github.com/klavis-ai/klavis/blob/main/mcp_servers/context7/packages/cli/README.md

Basic commands to get started with the CLI, including searching for skills, installing a specific skill, and listing installed skills for a client.

```bash
# Search for skills
ctx7 skills search pdf

# Install a skill
ctx7 skills install /anthropics/skills pdf

# List installed skills
ctx7 skills list --claude
```

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

### Local Installation Steps

Source: https://github.com/klavis-ai/klavis/blob/main/mcp_servers/twilio/README.md

Provides a step-by-step guide for local installation of the Twilio MCP server, including environment setup and dependency installation.

```bash
# 1. Navigate to the Twilio MCP server directory
cd mcp_servers/twilio

# 2. Create virtual environment and install dependencies
python -m venv venv
source venv/bin/activate  # On Windows: venv\Scripts\activate
pip install -r requirements.txt

# 3. Set up your environment
cp .env.example .env
# Edit .env with your Twilio credentials

# 4. Run the server
python server.py --stdio  # For Claude Desktop
# OR
python server.py          # For HTTP API testing
```

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

### Quick Start Example: Search Libraries and Get Context

Source: https://github.com/klavis-ai/klavis/blob/main/mcp_servers/context7/docs/sdks/ts/getting-started.mdx

Demonstrates searching for libraries based on a query and language, then retrieving documentation context for a specific library. It shows how to log the number of found libraries and their IDs, as well as the title and content of the documentation.

```typescript
import { Context7 } from "@upstash/context7-sdk";

const client = new Context7();

// Search for libraries
const libraries = await client.searchLibrary(
  "I need to build a UI with components",
  "react"
);
console.log(`Found ${libraries.length} libraries`);
console.log(libraries[0].id); // "/facebook/react"

// Get documentation as JSON array (default)
const docs = await client.getContext(
  "How do I use hooks?",
  "/facebook/react"
);
console.log(docs[0].title, docs[0].content);

// Get documentation context as plain text
const context = await client.getContext("How do I use hooks?", "/facebook/react", {
  type: "txt",
});
console.log(context);
```

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

### Setup Virtual Environment and Install Dependencies

Source: https://github.com/klavis-ai/klavis/blob/main/mcp_servers/yahoo_finance/CLAUDE.md

Use these commands to create a virtual environment and install project dependencies. Ensure you activate the environment before proceeding.

```bash
uv venv
source .venv/bin/activate  # Windows: .venv\Scripts\activate
uv pip install -e .
```

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

### Install Dependencies and Run Agent

Source: https://github.com/klavis-ai/klavis/blob/main/docs/ai-platform-integration/mastra.mdx

Install project dependencies using npm and start the development server.

```bash
npm install
npm run dev
```

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

### Run the Example Application

Source: https://github.com/klavis-ai/klavis/blob/main/examples/mastra-klavis/README.md

Starts the Mastra + Klavis Gmail agent. This will initiate a browser-based OAuth flow for Gmail authorization.

```bash
npm run dev
```

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

### Install and Run Fetch URL MCP Server

Source: https://github.com/klavis-ai/klavis/blob/main/docs/mcp-server/fetch_url.mdx

Install dependencies and start the Fetch URL MCP server locally. This involves running npm install, followed by build and start commands.

```bash
# install dependencies
npm install

# start the server
npm run build && npm start
```

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

### Install Mintlify CLI

Source: https://github.com/klavis-ai/klavis/blob/main/docs/README.md

Install the Mintlify CLI globally to preview documentation changes locally. This command is used for initial setup.

```bash
npm i -g mintlify
```

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

### Install mcpcurl using Go Install

Source: https://github.com/klavis-ai/klavis/blob/main/mcp_servers/github_mcpmark/cmd/mcpcurl/README.md

Install the mcpcurl CLI tool globally using the `go install` command. This is a convenient way to get the latest version.

```bash
go install github.com/github/github-mcp-server/cmd/mcpcurl@latest
```

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

### Run Office Word MCP Server Setup Script

Source: https://github.com/klavis-ai/klavis/blob/main/mcp_servers/local/word/README.md

Execute the setup script to handle prerequisites, virtual environment setup, dependency installation, and configuration generation.

```python
python setup_mcp.py
```

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

### Running the Example

Source: https://github.com/klavis-ai/klavis/blob/main/examples/langchain-klavis/typescript/README.md

Use these commands to run the example in development mode or after building.

```bash
# Development mode (with tsx)
npm run dev

# Or build and run
npm run build
npm start
```

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

### Get Context Example (Text)

Source: https://github.com/klavis-ai/klavis/blob/main/mcp_servers/context7/docs/api-guide.mdx

Retrieve documentation context in plain text format for LLM prompts. Replace CONTEXT7_API_KEY with your actual API key.

```bash
# Text format
curl "https://context7.com/api/v2/context?libraryId=/facebook/react&query=useEffect&type=txt" \
  -H "Authorization: Bearer CONTEXT7_API_KEY"
```

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

### Complete Workflow Example (Python)

Source: https://github.com/klavis-ai/klavis/blob/main/mcp_servers/context7/docs/api-guide.mdx

This Python script demonstrates a complete workflow: first searching for a library, then retrieving documentation context using the requests library. Ensure you have the 'requests' library installed and replace CONTEXT7_API_KEY with your actual API key.

```python
import requests

headers = {"Authorization": "Bearer CONTEXT7_API_KEY"}

# Step 1: Search for the library
search_response = requests.get(
    "https://context7.com/api/v2/libs/search",
    headers=headers,
    params={"libraryName": "react", "query": "I need to manage state"}
)
libraries = search_response.json()
best_match = libraries[0]
print(f"Found: {best_match['name']} ({best_match['id']})")

# Step 2: Get documentation context
context_response = requests.get(
    "https://context7.com/api/v2/context",
    headers=headers,
    params={"libraryId": best_match["id"], "query": "How do I use useState?"}
)
docs = context_response.json()

for doc in docs:
    print(f"Title: {doc['title']}")
    print(f"Content: {doc['content'][:200]}...")
```

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

### Start Local Deployment

Source: https://github.com/klavis-ai/klavis/blob/main/mcp_servers/fetch_toolathlon/README.md

Execute these commands to build and start the local development server.

```bash
npm run build
npm start
```

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

### Clone and Install HowToCook-MCP Server

Source: https://github.com/klavis-ai/klavis/blob/main/mcp_servers/howtocook/README_EN.md

Instructions for cloning the repository and installing project dependencies.

```bash
git clone https://github.com/worryzyy/howtocook-mcp.git
cd howtocook-mcp
```

```bash
npm install
```

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

### Get Context Example (JSON)

Source: https://github.com/klavis-ai/klavis/blob/main/mcp_servers/context7/docs/api-guide.mdx

Retrieve documentation context in JSON format for a specific library and query. Replace CONTEXT7_API_KEY with your actual API key.

```bash
# JSON format (default)
curl "https://context7.com/api/v2/context?libraryId=/facebook/react&query=useEffect" \
  -H "Authorization: Bearer CONTEXT7_API_KEY"
```

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

### Setup Python Virtual Environment for Figma Server

Source: https://github.com/klavis-ai/klavis/blob/main/mcp_servers/figma/README.md

Navigate to the Figma server directory, create and activate a virtual environment, and install dependencies.

```bash
# Navigate to the Figma server directory
cd mcp_servers/figma

# Create and activate virtual environment
python -m venv venv
source venv/bin/activate  # On Windows: venv\Scripts\activate

# Install dependencies
pip install -r requirements.txt

```

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

### Run Slack MCP Server (Node.js)

Source: https://github.com/klavis-ai/klavis/blob/main/mcp_servers/README.md

Installs Node.js dependencies and starts the Slack MCP server locally. Assumes you are in the correct directory.

```bash
git clone https://github.com/klavis-ai/klavis.git
cd klavis/mcp_servers/slack

npm install
npm start
```

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

### Install @upstash/context7-tools-ai-sdk

Source: https://github.com/klavis-ai/klavis/blob/main/mcp_servers/context7/docs/agentic-tools/ai-sdk/getting-started.mdx

Install the package using your preferred package manager.

```bash
npm install @upstash/context7-tools-ai-sdk
```

```bash
pnpm add @upstash/context7-tools-ai-sdk
```

```bash
yarn add @upstash/context7-tools-ai-sdk
```

```bash
bun add @upstash/context7-tools-ai-sdk
```

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

### Install MCP Server from Source

Source: https://github.com/klavis-ai/klavis/blob/main/mcp_servers/google_cloud_toolathlon/README.md

Clone the repository and install the package from source using pip.

```bash
git clone https://github.com/lockon-n/google-cloud-mcp.git
cd google-cloud-mcp
pip install -e .
```

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

### Basic Installation of Office Word MCP Server

Source: https://github.com/klavis-ai/klavis/blob/main/mcp_servers/local/word/README.md

Clone the repository and install dependencies using pip. Ensure Python 3.8+ is installed.

```bash
# Clone the repository
git clone https://github.com/GongRzhe/Office-Word-MCP-Server.git
cd Office-Word-MCP-Server

# Install dependencies
pip install -r requirements.txt
```

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

### Install DuckDuckGo MCP Server

Source: https://github.com/klavis-ai/klavis/blob/main/mcp_servers/duckduckgo_atlas/README.md

Install the server package from PyPI using the `uv` package manager. This is the recommended installation method.

```bash
uv pip install duckduckgo-mcp-server
```

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

### Install CLI

Source: https://github.com/klavis-ai/klavis/blob/main/mcp_servers/context7/packages/cli/README.md

Choose between running the CLI directly with npx for immediate use without installation, or installing it globally using npm for persistent access.

```bash
# Run directly with npx (no install needed)
npx ctx7

# Or install globally
npm install -g ctx7
```

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

### Install Dependencies

Source: https://github.com/klavis-ai/klavis/blob/main/mcp_servers/context7/packages/mcp/README.md

Install project dependencies using Bun. This command should be run after cloning the project.

```bash
bun i
```

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

### Install Dependencies

Source: https://github.com/klavis-ai/klavis/blob/main/mcp-clients/README-Slack.md

Install project dependencies using uv.

```bash
uv sync
```

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

### Install MCP Server with uv tool

Source: https://github.com/klavis-ai/klavis/blob/main/mcp_servers/google_cloud_toolathlon/README.md

Install the google-cloud-mcp package using the uv tool.

```bash
uv tool install google-cloud-mcp
```

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

### Set up Local Development Environment

Source: https://github.com/klavis-ai/klavis/blob/main/mcp_servers/msteams/README.md

Navigate to the server directory, create and activate a virtual environment, and install dependencies.

```bash
# Navigate to this server's directory
cd mcp_servers/msteams

# Create and activate a virtual environment
python -m venv .venv
.venv\Scripts\activate

# Install dependencies
pip install -r requirements.txt
```

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

### Setting up Brave Search MCP Server Steps

Source: https://github.com/klavis-ai/klavis/blob/main/docs/mcp-server/brave_search.mdx

Illustrates the steps involved in setting up the Brave Search MCP Server. Follow these steps sequentially for a correct setup.

```bash
npm install @brave-search/mcp-server
npx mcp-server init --config config.json
```

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

### Clone Project and Install Dependencies

Source: https://github.com/klavis-ai/klavis/blob/main/mcp_servers/context7/docs/resources/developer.mdx

Clone the Context7 repository and install its dependencies using pnpm.

```bash
git clone https://github.com/upstash/context7.git
cd context7
pnpm i
```

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

### Clone and Install gsuite-mcp Manually

Source: https://github.com/klavis-ai/klavis/blob/main/mcp_servers/google_workspace_atlas/README.md

Clones the repository and installs Node.js dependencies for manual setup.

```bash
git clone https://github.com/epaproditus/google-workspace-mcp-server.git
cd google-workspace-mcp-server
npm install
```

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

### Install Dependencies without Project/Dev/Editable

Source: https://github.com/klavis-ai/klavis/blob/main/mcp_servers/scholarly_toolathlon/CLAUDE.md

This command installs dependencies, excluding the project itself, development dependencies, and editable installs. Useful for clean environment setups.

```bash
uv sync --no-install-project --no-dev --no-editable
```

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

### Install Required Packages

Source: https://github.com/klavis-ai/klavis/blob/main/examples/together-klavis/Agents_KlavisAI.ipynb

Installs the necessary Python packages for Together AI and Klavis integration. Use this at the beginning of your project setup.

```python
%pip install -qU together klavis
```

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

### Start Local Development Server

Source: https://github.com/klavis-ai/klavis/blob/main/docs/README.md

Run the Mintlify development server from the root of your documentation project. Ensure docs.json is present in the directory.

```bash
mintlify dev
```

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

### Initialize Klavis and Create Spotify Server Instance

Source: https://github.com/klavis-ai/klavis/blob/main/mcp_servers/spotify/README.md

Initialize the Klavis client with your API key and create a Spotify MCP server instance. Replace 'your-free-key' with your actual Klavis API key.

```python
from klavis import Klavis

klavis = Klavis(api_key="your-free-key")
server = klavis.mcp_server.create_server_instance("SPOTIFY", "user123")
```

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

### Run Stream Example

Source: https://github.com/klavis-ai/klavis/blob/main/docs/quickstart.mdx

Example of running a streaming task with Strata's agent. Ensure you have the necessary imports and agent setup.

```python
import asyncio
from klavis.agents import Agent
from klavis.console import Console
from klavis.types import Cancellation

async def main():
    agent = Agent(
        system_message="You are a helpful AI assistant."
    )

    await Console(
        agent.run_stream(
            task="Get my latest mails.",
            cancellation_token=Cancellation(),
        )
    )

if __name__ == "__main__":
    asyncio.run(main())

```

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

### Install MCP Scholarly via Smithery CLI

Source: https://github.com/klavis-ai/klavis/blob/main/mcp_servers/scholarly/README.md

Install the mcp-scholarly server for Claude Desktop using the Smithery CLI. This command automates the setup process.

```bash
npx -y @smithery/cli install mcp-scholarly --client claude
```

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

### Quick Start: Create MCP Server Instance

Source: https://github.com/klavis-ai/klavis/blob/main/docs/sdk/python.mdx

Initialize the Klavis client and create an MCP server instance for YouTube. Replace 'your-klavis-key' with your actual API key and 'user123' with your platform's user ID.

```python
from klavis import Klavis
from klavis.types import McpServerName

klavis_client = Klavis(api_key="your-klavis-key")

# Create a YouTube MCP server instance
youtube_server = klavis_client.mcp_server.create_server_instance(
    server_name=McpServerName.YOUTUBE,
    user_id="user123", # Change to user id in your platform
)

print(f"Server created: {youtube_server.server_url}")
```

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

### Install Whois MCP Server Globally

Source: https://github.com/klavis-ai/klavis/blob/main/mcp_servers/whois/README.md

Run the MCP server globally using npx for immediate use. This command installs and starts the server, making its tools available.

```bash
npx -y @bharathvaj/whois-mcp@latest
```

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

### Example: Add Notion MCP Server

Source: https://github.com/klavis-ai/klavis/blob/main/examples/google_gemini_cli-klavis/README.md

Demonstrates adding a Notion MCP server to your Gemini configuration.

```bash
klavis gemini add https://notion-mcp-server.klavis.ai/mcp/?instance_id=your-id
```

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

### Get Help for a Specific MCP Tool

Source: https://github.com/klavis-ai/klavis/blob/main/mcp_servers/github_mcpmark/cmd/mcpcurl/README.md

To understand the usage and available flags for a particular tool, append the tool name to the 'tools' command followed by '--help'. This example shows how to get help for the 'get_issue' tool.

```console
% ./mcpcurl --stdio-server-cmd "docker run -i --rm -e GITHUB_PERSONAL_ACCESS_TOKEN mcp/github" tools get_issue --help
```

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

### Environment Variables Setup

Source: https://github.com/klavis-ai/klavis/blob/main/examples/langchain-klavis/typescript/README.md

Create a .env file and populate it with your Klavis and OpenAI API keys. Replace placeholder values with your actual API keys.

```bash
# Klavis API Key - Get from https://klavis.io
KLAVIS_API_KEY=your_klavis_api_key_here

# OpenAI API Key - Get from https://platform.openai.com
OPENAI_API_KEY=your_openai_api_key_here
```

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

### Server Configuration Example

Source: https://github.com/klavis-ai/klavis/blob/main/mcp_servers/perplexity_ai/README.md

Set the port for the Perplexity MCP Server by creating a .env file.

```bash
PERPLEXITY_MCP_SERVER_PORT=5000
```

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

### Example Instruction: Get Page Content by ID

Source: https://github.com/klavis-ai/klavis/blob/main/mcp_servers/notion_official/README.md

This instruction demonstrates how to retrieve content from a Notion page by directly referencing its content ID.

```text
Get the content of page 1a6b35e6e67f802fa7e1d27686f017f2
```

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

### Set up Local Development Environment

Source: https://github.com/klavis-ai/klavis/blob/main/mcp_servers/twilio/README.md

Sets up a Python virtual environment and installs project dependencies using pip. Activate the virtual environment before installing.

```bash
python -m venv venv
source venv/bin/activate  # On Windows: venv\Scripts\activate
pip install -r requirements.txt
```

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

### Run GitHub MCP Server with Docker (No Auth)

Source: https://github.com/klavis-ai/klavis/blob/main/mcp_servers/README.md

Pulls and runs the GitHub MCP server Docker image. This example does not include authentication setup.

```bash
docker pull ghcr.io/klavis-ai/github-mcp-server:latest
docker run -p 5000:5000 ghcr.io/klavis-ai/github-mcp-server:latest
```

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

### Run HowToCook-MCP Server

Source: https://github.com/klavis-ai/klavis/blob/main/mcp_servers/howtocook/README.md

Starts the HowToCook-MCP server using default settings.

```bash
npm start
```

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

### Run Server

Source: https://github.com/klavis-ai/klavis/blob/main/mcp_servers/local/Poste.io/README.md

Starts the Poste.io email server for local development using uv run.

```bash
uv run python -m emails_mcp.server
```

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

### Initialize ClickUp MCP Server Instance (Python)

Source: https://github.com/klavis-ai/klavis/blob/main/mcp_servers/clickup/README.md

Initialize the Klavis SDK with your API key and create an instance of the ClickUp MCP server. Replace 'your-free-key' with your actual Klavis API key.

```python
from klavis import Klavis

klavis = Klavis(api_key="your-free-key")
server = klavis.mcp_server.create_server_instance("CLICKUP", "user123")
```

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

### Configure MCP Client for Mem0

Source: https://github.com/klavis-ai/klavis/blob/main/docs/mcp-server/mem0.mdx

Example JSON configuration for an MCP client to connect to a locally running Mem0 MCP server. Ensure the URL matches your Docker setup.

```json
{
  "mcpServers": {
    "mem0": {
      "url": "http://localhost:5000/mcp/"
    }
  }
}
```

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

### Configure MCP Client for Dropbox

Source: https://github.com/klavis-ai/klavis/blob/main/docs/mcp-server/dropbox.mdx

Example JSON configuration for an MCP client to connect to a locally running Dropbox MCP server. Ensure the URL matches your Docker setup.

```json
{
  "mcpServers": {
    "dropbox": {
      "url": "http://localhost:5000/mcp/"
    }
  }
}
```

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

### Run Postgres MCP Pro Server

Source: https://github.com/klavis-ai/klavis/blob/main/mcp_servers/postgres/README.md

Starts the Postgres MCP Pro server using the uv run command. This command is used to launch the application after dependencies are installed.

```bash
uv run postgres-mcp
```

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

### Install Hugging Face MCP Server in Gemini CLI

Source: https://github.com/klavis-ai/klavis/blob/main/mcp_servers/hugging_face/README.md

Command to add the Hugging Face connector to Gemini CLI. Authentication is completed by starting `gemini` and following the prompts.

```bash
gemini mcp add -t http huggingface https://huggingface.co/mcp?login
```

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

### Initialize Klavis and Anthropic Clients

Source: https://github.com/klavis-ai/klavis/blob/main/examples/claude-klavis/python/Use_Strata_with_Claude.ipynb

Sets up environment variables for API keys and initializes the Klavis and Anthropic clients. Replace placeholder keys with your actual credentials.

```python
import os
import webbrowser
from klavis import Klavis
from klavis.types import McpServerName, ToolFormat
from anthropic import Anthropic

# Set environment variables
os.environ["ANTHROPIC_API_KEY"] = "YOUR_ANTHROPIC_API_KEY"  # Replace with your actual Anthropic API key
os.environ["KLAVIS_API_KEY"] = "YOUR_KLAVIS_API_KEY"  # Replace with your actual Klavis API key
```

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

### Summarize YouTube Video with Gemini

Source: https://github.com/klavis-ai/klavis/blob/main/examples/google_genai-klavis/Use_Klavis_with_Gemini.ipynb

Use this snippet to get a summary of a YouTube video. Ensure you have the necessary Klavis and Gemini setup. The output includes the video summary with timestamps.

```python
YOUTUBE_VIDEO_URL = "https://www.youtube.com/watch?v=LCEmiRjPEtQ"  # pick a video you like!

result = gemini_with_mcp_server(
    mcp_server_url=youtube_mcp_instance.server_url, 
    user_query=f"Please provide a complete summary of this YouTube video with timestamp: {YOUTUBE_VIDEO_URL}"
)

print(result)
```

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

### Start Filesystem MCP Server with Command-line Arguments

Source: https://github.com/klavis-ai/klavis/blob/main/mcp_servers/local/filesystem/README.md

Specify allowed directories when starting the server using command-line arguments.

```bash
mcp-server-filesystem /path/to/dir1 /path/to/dir2
```

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

### Example JSON block without the MCP key

Source: https://github.com/klavis-ai/klavis/blob/main/mcp_servers/github_mcpmark/README.md

This JSON configuration can be placed in `.vscode/mcp.json` to share the server setup with other host applications that support the same format, excluding the top-level 'mcp' key.

```json
{
  "inputs": [
    {
      "type": "promptString",
      "id": "github_token",
      "description": "GitHub Personal Access Token",
      "password": true
    }
  ],
  "servers": {
    "github": {
      "command": "docker",
      "args": [
        "run",
        "-i",
        "--rm",
        "-e",
        "GITHUB_PERSONAL_ACCESS_TOKEN",
        "ghcr.io/github/github-mcp-server"
      ],
      "env": {
        "GITHUB_PERSONAL_ACCESS_TOKEN": "${input:github_token}"
      }
    }
  }
}
```

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

### Initialize Klavis and LangChain Components

Source: https://github.com/klavis-ai/klavis/blob/main/examples/langchain-klavis/python/Use_Strata_with_LangChain.ipynb

Sets up environment variables for API keys and imports necessary classes from Klavis, LangChain, and LangGraph. Replace placeholder API keys with your actual credentials.

```python
import os
import webbrowser
from klavis import Klavis
from klavis.types import McpServerName
from langchain_openai import ChatOpenAI
from langchain_mcp_adapters.client import MultiServerMCPClient
from langgraph.prebuilt import create_react_agent

# Set environment variables
os.environ["OPENAI_API_KEY"] = "YOUR_OPENAI_API_KEY"  # Replace with your actual OpenAI API key
os.environ["KLAVIS_API_KEY"] = "YOUR_KLAVIS_API_KEY"  # Replace with your actual Klavis API key

```

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

### Configure MongoDB MCP Server with Command-Line Arguments

Source: https://github.com/klavis-ai/klavis/blob/main/mcp_servers/mongodb/README.md

Start the MongoDB MCP server and configure it using command-line arguments. This method is convenient for quick setups or when environment variables are not preferred.

```shell
npx -y mongodb-mcp-server --apiClientId="your-atlas-service-accounts-client-id" --apiClientSecret="your-atlas-service-accounts-client-secret" --connectionString="mongodb+srv://username:password@cluster.mongodb.net/myDatabase" --logPath=/path/to/logs --readOnly --indexCheck

```

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

### Example: Add Slack MCP Server

Source: https://github.com/klavis-ai/klavis/blob/main/examples/google_gemini_cli-klavis/README.md

Demonstrates adding a Slack MCP server to your Gemini configuration.

```bash
klavis gemini add https://slack-mcp-server.klavis.ai/mcp/?instance_id=your-id
```

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

### Create Google Meet Event

Source: https://github.com/klavis-ai/klavis/blob/main/mcp_servers/google_meet/README.md

Example JSON payload for creating a new Google Meet event. Includes details such as summary, start and end times, attendees, and notification preferences.

```json
{
  "name": "google_meet_create_meet",
  "arguments": {
    "summary": "Team Sync",
    "start_time": "2025-09-05T10:00:00Z",
    "end_time": "2025-09-05T10:30:00Z",
    "attendees": ["a@example.com","b@example.com"],
    "description": "Daily standup",
    "notify_attendees": true
  }
}
```

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

### Set Environment Variables for SSE/Streamable HTTP Transports (Windows)

Source: https://github.com/klavis-ai/klavis/blob/main/mcp_servers/local/excel/README.md

Example using PowerShell to set the EXCEL_FILES_PATH and FASTMCP_PORT environment variables on Windows before starting the server with SSE or Streamable HTTP transport.

```powershell
$env:EXCEL_FILES_PATH="E:\MyExcelFiles"
$env:FASTMCP_PORT="8007"
uvx excel-mcp-server streamable-http
```

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

### Initialize and Use Context7 SDK

Source: https://github.com/klavis-ai/klavis/blob/main/mcp_servers/context7/packages/sdk/README.md

Initialize the client with your API key and use it to search for libraries or retrieve documentation. The SDK supports fetching documentation as JSON or plain text.

```typescript
import { Context7 } from "@upstash/context7-sdk";

const client = new Context7({
  apiKey: "<CONTEXT7_API_KEY>",
});

// Search for libraries
const libraries = await client.searchLibrary(
  "I need to build a UI with components",
  "react"
);
console.log(libraries[0].id); // "/facebook/react"

// Get documentation as JSON array (default)
const docs = await client.getContext("How do I use hooks?", "/facebook/react");
console.log(docs[0].title, docs[0].content);

// Get documentation context as plain text
const context = await client.getContext(
  "How do I use hooks?",
  "/facebook/react",
  { type: "txt" }
);
console.log(context);
```

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

### Set Custom System Prompt for Context7Agent

Source: https://github.com/klavis-ai/klavis/blob/main/mcp_servers/context7/docs/agentic-tools/ai-sdk/agents/context7-agent.mdx

Override the default system prompt with custom instructions to guide the agent's responses. This allows for tailored behavior, such as always including TypeScript examples.

```typescript
import { Context7Agent, AGENT_PROMPT } from "@upstash/context7-tools-ai-sdk";
import { openai } from "@ai-sdk/openai";

const agent = new Context7Agent({
  model: openai("gpt-5.2"),
  system: `${AGENT_PROMPT}`,

Additional instructions:
- Always include TypeScript examples
- Mention version compatibility when relevant
- Suggest related documentation topics`,
});
```

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

### Create HubSpot MCP Server Instance (Python)

Source: https://github.com/klavis-ai/klavis/blob/main/mcp_servers/hubspot/README.md

Initialize the Klavis client with your API key and create a HubSpot MCP server instance. This is part of the quick start guide for using the hosted service.

```python
from klavis import Klavis

klavis = Klavis(api_key="your-free-key")
server = klavis.mcp_server.create_server_instance("HUBSPOT", "user123")
```

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

### Example Prompt Specifying Library Version

Source: https://github.com/klavis-ai/klavis/blob/main/mcp_servers/context7/README.md

Mention a specific library version in your prompt to ensure Context7 retrieves documentation for that exact version.

```txt
How do I set up Next.js 14 middleware? use context7
```

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

### Install Context7 SDK with bun

Source: https://github.com/klavis-ai/klavis/blob/main/mcp_servers/context7/docs/sdks/ts/getting-started.mdx

Install the SDK using bun. This is a fast, all-in-one JavaScript runtime and toolkit.

```shell
bun add @upstash/context7-sdk
```

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

### Initiate Xero OAuth with White-Label (TypeScript SDK)

Source: https://github.com/klavis-ai/klavis/blob/main/docs/knowledge-base/oauth_app/xero.mdx

This TypeScript example demonstrates initiating the Xero OAuth flow using the Klavis SDK when white-labeling is enabled. Ensure you have the SDK installed and your API key configured.

```typescript
import { Klavis } from "@klavis/sdk";

const klavis = new Klavis({
  apiKey: "YOUR_API_KEY"
});

// Example: Initiating Xero OAuth with white-label
const oauthUrl = await klavis.mcpServer.getOAuthUrl({
  serverName: Klavis.McpServerName.Xero,
  instanceId: instanceId,
  clientId: yourClientId,
  // redirectUri: YOUR_REDIRECT_URI,
  // scope: "YOUR_SCOPES", 
});

window.location.href = oauthUrl;
```

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

### Initialize API Clients and Set Environment Variables

Source: https://github.com/klavis-ai/klavis/blob/main/examples/together-klavis/Agents_KlavisAI.ipynb

Sets up the environment variables for your Together AI and Klavis API keys and initializes the respective client libraries. Replace placeholder keys with your actual API keys.

```python
import os
import json
from together import Together
from klavis import Klavis
from klavis.types import McpServerName, ToolFormat

# Set environment variables
os.environ["TOGETHER_API_KEY"] = "your-together-api-key-here"  # Replace with your actual Together API key
os.environ["KLAVIS_API_KEY"] = "your-klavis-api-key-here"      # Replace with your actual Klavis API key
```

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

### Local Development Setup for Trello MCP Server

Source: https://github.com/klavis-ai/klavis/blob/main/mcp_servers/trello/README.md

Set up the Trello MCP server for local development by navigating to the directory, creating a virtual environment, installing dependencies, configuring credentials in a .env file, and running the server.

```bash
cd mcp_servers/trello

uv venv
.venv\Scripts\activate

uv pip install -r requirements.txt

# Create a .env file with your Trello credentials
# TRELLO_API_KEY=your_key
# TRELLO_API_TOKEN=your_token

python server.py
```

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

### Example: Add Gmail MCP Server

Source: https://github.com/klavis-ai/klavis/blob/main/examples/google_gemini_cli-klavis/README.md

Demonstrates adding a Gmail MCP server to your Gemini configuration.

```bash
klavis gemini add https://gmail-mcp-server.klavis.ai/mcp/?instance_id=your-id
```

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

### System Prompt for Chat Personalization

Source: https://github.com/klavis-ai/klavis/blob/main/mcp_servers/local/memory/README.md

An example system prompt to guide the model in chat personalization, focusing on user identification, memory retrieval, memory categories, and update procedures. This prompt can be used in the 'Custom Instructions' field of a Claude.ai Project.

```text
Follow these steps for each interaction:

1. User Identification:
   - You should assume that you are interacting with default_user
   - If you have not identified default_user, proactively try to do so.

2. Memory Retrieval:
   - Always begin your chat by saying only "Remembering..." and retrieve all relevant information from your knowledge graph
   - Always refer to your knowledge graph as your "memory"

3. Memory
   - While conversing with the user, be attentive to any new information that falls into these categories:
     a) Basic Identity (age, gender, location, job title, education level, etc.)
     b) Behaviors (interests, habits, etc.)
     c) Preferences (communication style, preferred language, etc.)
     d) Goals (goals, targets, aspirations, etc.)
     e) Relationships (personal and professional relationships up to 3 degrees of separation)

4. Memory Update:
   - If any new information was gathered during the interaction, update your memory as follows:
     a) Create entities for recurring organizations, people, and significant events
     b) Connect them to the current entities using relations
     c) Store facts about them as observations
```

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

### Execute MCP Tool: Get Issue Details

Source: https://github.com/klavis-ai/klavis/blob/main/mcp_servers/github_mcpmark/cmd/mcpcurl/README.md

This example demonstrates how to use the 'get_issue' tool to retrieve details of a specific issue from a GitHub repository. Provide the owner, repository name, and the issue number as arguments. The output is a JSON object containing the issue details.

```console
% ./mcpcurl --stdio-server-cmd "docker run -i --rm -e GITHUB_PERSONAL_ACCESS_TOKEN mcp/github" tools get_issue --owner golang --repo go --issue_number 1
```

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

### Create Strata MCP Server and LangChain Agent

Source: https://github.com/klavis-ai/klavis/blob/main/docs/quickstart.mdx

This example demonstrates creating a Klavis MCP server with Gmail and YouTube integrations, handling OAuth, and setting up a LangChain agent with MCP tools. Replace 'demo_user' and the example email with your actual values.

```python
import os
import asyncio
import webbrowser

from klavis import Klavis
from klavis.types import McpServerName
from langchain_openai import ChatOpenAI
from langchain_mcp_adapters.client import MultiServerMCPClient
from langgraph.prebuilt import create_react_agent

from dotenv import load_dotenv
load_dotenv()

async def main():
    klavis_client = Klavis(api_key=os.getenv("KLAVIS_API_KEY"))

    # Step 1: Create a Strata MCP server with Gmail and YouTube integrations
    response = klavis_client.mcp_server.create_strata_server(
        user_id="demo_user",
        servers=[McpServerName.GMAIL, McpServerName.YOUTUBE],
    )

    # Step 2: Handle OAuth authorization if needed
    if response.oauth_urls:
        for server_name, oauth_url in response.oauth_urls.items():
            webbrowser.open(oauth_url)
            input(f"Press Enter after completing {server_name} OAuth authorization...")

    # Step 3: Create LangChain Agent with MCP Tools
    mcp_client = MultiServerMCPClient({
        "strata": {
            "transport": "streamable_http",
            "url": response.strata_server_url,
        }
    })

    # Get all available tools from Strata
    tools = await mcp_client.get_tools()
    # Setup LLM
    llm = ChatOpenAI(model="gpt-4o-mini", api_key=os.getenv("OPENAI_API_KEY"))
    
    # Step 4: Create LangChain agent with MCP tools
    agent = create_react_agent(
        model=llm,
        tools=tools,
        prompt=(
            "You are a helpful assistant that can use MCP tools. "
        ),
    )

    my_email = "golden-kpop@example.com" # TODO: Replace with your email
    # Step 5: Invoke the agent
    result = await agent.ainvoke({
        "messages": [{"role": "user", "content": f"summarize this video - https://youtu.be/yebNIHKAC4A?si=1Rz_ZsiVRz0YfOR7 and send the summary to my email {my_email}"}],
    })
    
    # Print only the final AI response content
    print(result["messages"][-1].content)

if __name__ == "__main__":
    asyncio.run(main())
```

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

### Install Dependencies with npm

Source: https://github.com/klavis-ai/klavis/blob/main/examples/mastra-klavis/README.md

Installs the necessary project dependencies. Ensure Node.js is installed.

```bash
npm install
```

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

### Install Postgres MCP Pro with uv

Source: https://github.com/klavis-ai/klavis/blob/main/mcp_servers/postgres/README.md

Install Postgres MCP Pro using uv, a fast Python package installer. Refer to uv documentation for installation instructions if needed.

```bash
uv pip install postgres-mcp
```

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

### Set Up Environment Variables

Source: https://github.com/klavis-ai/klavis/blob/main/docs/ai-platform-integration/langchain.mdx

Configure your environment with OpenAI and Klavis API keys. Ensure these keys are kept secure.

```python Python
import os

os.environ["OPENAI_API_KEY"] = "YOUR_OPENAI_API_KEY"  # Replace
os.environ["KLAVIS_API_KEY"] = "YOUR_KLAVIS_API_KEY"  # Replace
```

```typescript TypeScript
import { config } from 'dotenv';

// Load environment variables from .env file
config();

// Make sure you have a .env file with:
// OPENAI_API_KEY=your_openai_api_key
// KLAVIS_API_KEY=your_klavis_api_key
```

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

### Install Skills

Source: https://github.com/klavis-ai/klavis/blob/main/mcp_servers/context7/packages/cli/README.md

Commands for installing skills from a project repository to your AI coding assistant's skills directory. Supports installing all, specific, or multiple skills, and targeting specific clients or global installation.

```bash
# Install all skills from a project (interactive selection)
ctx7 skills install /anthropics/skills

# Install a specific skill
ctx7 skills install /anthropics/skills pdf

# Install multiple skills at once
ctx7 skills install /anthropics/skills pdf commit

# Install to a specific client
ctx7 skills install /anthropics/skills pdf --cursor
ctx7 skills install /anthropics/skills pdf --claude

# Install globally (home directory instead of current project)
ctx7 skills install /anthropics/skills pdf --global
```

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

### CodeRabbit Usage Guidance Example

Source: https://github.com/klavis-ai/klavis/blob/main/mcp_servers/context7/docs/integrations/code-rabbit.mdx

Provide instructions in the 'Usage Guidance' field to instruct CodeRabbit on how to utilize Context7 during code reviews. This example prompts CodeRabbit to use Context7 for library documentation lookups and verification against the latest API references.

```text
Use Context7 to look up documentation for any libraries used in the code being reviewed.
Verify that API usage matches the latest documentation and flag any deprecated patterns.
```

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

### Install Strata MCP

Source: https://github.com/klavis-ai/klavis/blob/main/open-strata/README.md

Install the Strata MCP package using pipx or pip. For development, use an editable install.

```bash
pipx install strata-mcp
```

```bash
pip install strata-mcp
```

```bash
pip install -e .
```

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

### Install Dependencies

Source: https://github.com/klavis-ai/klavis/blob/main/mcp_servers/context7/packages/tools-ai-sdk/README.md

Install the necessary packages for using the Context7 AI SDK with Vercel AI SDK, AI, and Zod.

```bash
npm install @upstash/context7-tools-ai-sdk @upstash/context7-sdk ai zod
```

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

### Install Skills from Registry

Source: https://github.com/klavis-ai/klavis/blob/main/mcp_servers/context7/docs/skills.mdx

Install skills from a project repository to your AI coding assistant's skills directory. You can install all skills, specific skills, or multiple skills at once. Options include installing to a specific client or globally.

```bash
# Install all skills from a project (interactive selection)
ctx7 skills install /anthropics/skills
```

```bash
# Install a specific skill
ctx7 skills install /anthropics/skills pdf
```

```bash
# Install multiple skills at once
ctx7 skills install /anthropics/skills pdf commit
```

```bash
# Install to a specific client
ctx7 skills install /anthropics/skills pdf --cursor
```

```bash
ctx7 skills install /anthropics/skills pdf --claude
```

```bash
# Install globally (home directory instead of current project)
ctx7 skills install /anthropics/skills pdf --global
```