# Access & Authentication
Source: https://docs.membit.ai/access-and-auth

Learn how to get your API key and authenticate with the Membit API.

Getting started with the Membit API is simple. Follow these steps to get your API key and make your first request.

<Steps>
  <Step title="Sign in to Membit">
    First, head over to [membit.ai](https://membit.ai) and sign in using your
    GitHub or Google account.
  </Step>

  <Step title="Get your API key">
    <img alt="Membit API key generation interface" />

    Once you're signed in, you'll be able to generate a free API key from your account
    dashboard. This key will give you access to the Membit API.
  </Step>

  <Step title="Authenticate your requests">
    To authenticate your requests, you'll need to include your API key in the
    `Authorization` header of your requests, prefixed with `Bearer `.
  </Step>
</Steps>

<Warning>Keep your API key secure and do not share it publicly.</Warning>


# MCP Server
Source: https://docs.membit.ai/api-usage/mcp-server

Use Membit's Model Context Protocol (MCP) server to give AI agents real-time social context.

Membit MCP Server connects your AI systems to live social insights via Membit's API. Using the Model Context Protocol (MCP), the server exposes tools that make up-to-the-minute social context—trending discussion clusters, raw posts, and more—available to your AI agents in Cursor, Claude Desktop, Goose, and any MCP-compatible client.

## Available tools

These tools are exposed by the Membit MCP server and can be called by MCP-compatible clients (e.g., Cursor, Claude Desktop).

### clusters.search

Search for trending discussion clusters across platforms.

<ParamField type="string">
  Free-text query describing the topic (e.g., "ai agents", "us elections").
</ParamField>

<ParamField type="integer">
  Maximum number of clusters to return. Range: 1–50.
</ParamField>

### clusters.info

Get detailed context for a specific cluster label, including representative posts.

<ParamField type="string">
  Cluster label obtained from `clusters.search`.
</ParamField>

<ParamField type="integer">
  Maximum number of representative posts to include. Range: 1–50.
</ParamField>

### posts.search

Search raw social posts that match your query across supported platforms.

<ParamField type="string">
  Free-text query describing the topic or keywords.
</ParamField>

<ParamField type="integer">
  Maximum number of posts to return. Range: 1–100.
</ParamField>

<Tip>
  All tools respect privacy: results surface public conversations only and never
  expose personal identifiers beyond public metadata.
</Tip>

## Remote MCP Server

Connect Membit's remote MCP server directly without the need for local setup. This approach offers a streamlined experience that eliminates local installation and configuration requirements.

Use the remote MCP server endpoint with your Membit API key:

```text theme={null}
https://mcp.membit.ai/mcp
```

**Authentication**: The remote server requires your API key to be passed as an HTTP header `X-Membit-Api-Key: <your-api-key>`. The configurations below handle this automatically for each client.

Obtain your [Membit API key](/access-and-auth).

### Configuring Remote MCP Clients

See platform-specific setup guides in the **Integrations** section.

## Local MCP

Run the server locally if you prefer.

### Requirements

* Membit API key ([get one](/access-and-auth))
* Python 3.11+
* An MCP client (e.g., Claude Desktop, Goose, Cursor)
* Git (optional, if cloning)

### API Key Configuration

Provide your key in one of two ways:

**Environment variable (recommended):**

Create a `.env` file in the project root:

```bash theme={null}
MEMBIT_API_KEY=<your-api-key>
```

**HTTP header (useful for direct HTTP testing):**

```bash theme={null}
curl -H 'X-Membit-Api-Key: <your-api-key>' http://localhost:8000/mcp
```

### Installation Guide

#### Clone from Git

<Steps>
  <Step title="Clone the Repository">
    ```bash theme={null}
    git clone https://github.com/bandprotocol/membit-mcp.git
    cd membit-mcp
    ```
  </Step>

  <Step title="Choose Installation Method">
    **Option 1: Direct Installation**

    ```bash theme={null}
    uv sync
    uv run src/membit_mcp/server.py
    ```

    **Option 2: Docker Installation**

    Build the Docker image:

    ```bash theme={null}
    docker build -t membit-mcp .
    ```

    Run the container:

    ```bash theme={null}
    # Using environment variable
    docker run -p 8000:8000 -e MEMBIT_API_KEY=<your-api-key> membit-mcp

    # Using HTTP header
    docker run -p 8000:8000 membit-mcp
    # Then use: curl -H 'X-Membit-Api-Key: <your-api-key>' http://localhost:8000/mcp
    ```
  </Step>
</Steps>


# Python SDK
Source: https://docs.membit.ai/api-usage/python

Use the Membit Python SDK to access real-time social context with simple sync/async APIs.

Membit's Python SDK provides a simple interface to the Membit API. Add intelligent search and content discovery directly to your apps with sync and async support.

## Installing

```bash theme={null}
pip install membit-python
```

Or with uv:

```bash theme={null}
uv add membit-python
```

## Membit Cluster Search

Discover trending topics and clusters of related content. Ideal for understanding what's trending and grouping related discussions.

### Usage

```python theme={null}
from membit import MembitClient

client = MembitClient(api_key="your_api_key_here")
clusters = client.cluster_search("artificial intelligence", limit=3)
print(clusters)
```

## Membit Cluster Info

Fetch detailed information about a specific cluster. Use this to dive deeper into topics discovered via cluster search.

### Usage

```python theme={null}
from membit import MembitClient

client = MembitClient(api_key="your_api_key_here")
cluster_info = client.cluster_info("AI Learning Resources", limit=5, output_format="json")
print("Cluster Info:", cluster_info)
```

## Membit Post Search

Search for individual posts across the Membit corpus. Perfect for finding specific content and examples.

### Usage

```python theme={null}
from membit import MembitClient

client = MembitClient(api_key="your_api_key_here")
posts = client.post_search("machine learning", limit=10, output_format="json")
print("Found posts:", posts)
```

## Async Support

For applications that need high performance or handle multiple concurrent requests:

```python theme={null}
import asyncio
from membit import AsyncMembitClient

async def analyze_topics():
    client = AsyncMembitClient(api_key="your_api_key_here")

    # Search for trending clusters asynchronously
    clusters = await client.cluster_search("tech news", limit=5)

    # Get detailed info for multiple clusters concurrently
    if clusters.get("clusters"):
        tasks = [
            client.cluster_info(label=cluster["label"])
            for cluster in clusters["clusters"]
        ]
        cluster_details = await asyncio.gather(*tasks)

        for details in cluster_details:
            print(details)

# Run the async function
asyncio.run(analyze_topics())
```

## Defaults and Configuration

All search methods support these options (defaults shown):

* **limit**: 10 — Maximum number of results to return
* **output\_format**: "json" — "json" for structured data, "llm" for text
* **timeout**: 60 — Request timeout in seconds

## Environment Variables

You can set your API key via environment variable:

```bash theme={null}
export MEMBIT_API_KEY="<your-api-key>"
```

If `api_key` is not provided to the client, the SDK will automatically use `MEMBIT_API_KEY`.

## Examples

Complete working examples are available in [`membit-python`](https://github.com/bandprotocol/membit-python)'s `examples/` directory:

* `examples/client.py` — Synchronous client usage
* `examples/async_client.py` — Asynchronous client usage


# TypeScript SDK
Source: https://docs.membit.ai/api-usage/typescript

Use the Membit JavaScript/TypeScript SDK to access real-time context with strong typing and simple APIs.

Membit's JavaScript/TypeScript SDK provides a simple, strongly-typed interface to the Membit API. Add intelligent search and content discovery directly to your apps with first-class TypeScript support and automatic type inference.

## Installing

```bash theme={null}
npm i @bandprotocol/membit
```

## Membit Cluster Search

Discover trending topics and clusters of related content. Ideal for understanding what's trending and grouping related discussions.

### Usage

```javascript theme={null}
const { membit } = require("@bandprotocol/membit");

// Step 1. Instantiate the Membit client
const client = membit({ apiKey: "<your-api-key>" });

// Step 2. Execute a cluster search query
const clusters = await client.cluster_search("artificial intelligence", {
  limit: 3,
});

// Step 3. Done! You've performed a Membit Cluster Search
console.log(clusters);
```

## Membit Cluster Info

Fetch detailed information about a specific cluster. Use this to dive deeper into topics discovered via cluster search.

### Usage

```javascript theme={null}
const { membit } = require("@bandprotocol/membit");

// Step 1. Instantiate the Membit client
const client = membit({ apiKey: "<your-api-key>" });

// Step 2. Get detailed cluster information
const clusterInfo = await client.cluster_info("AI Learning Resources", {
  limit: 5,
  format: "json",
});

// Step 3. Print cluster details
console.log("Cluster Info:", clusterInfo);
```

## Membit Post Search

Search for individual posts across the Membit corpus. Perfect for finding specific content and examples.

### Usage

```javascript theme={null}
const { membit } = require("@bandprotocol/membit");

// Step 1. Instantiate the Membit client
const client = membit({ apiKey: "<your-api-key>" });

// Step 2. Search for posts
const posts = await client.post_search("machine learning", {
  limit: 10,
  format: "json",
});

// Step 3. Process the results
console.log("Found posts:", posts);
```

## TypeScript Benefits

### Method Overloads

```typescript theme={null}
// TypeScript automatically infers return types
const jsonData = await client.cluster_search("query"); // Record<string, any>
const textData = await client.cluster_search("query", { format: "llm" }); // string
```

### Format Options

| Format | Return Type           | Use Case                               | TypeScript Type |
| ------ | --------------------- | -------------------------------------- | --------------- |
| "json" | `Record<string, any>` | Structured data for further processing | Object          |
| "llm"  | string                | Human-readable text for direct display | String          |

### Configuration Options

```typescript theme={null}
import { membit, MembitClientOptions } from "@bandprotocol/membit";

const client = membit({
  apiKey: "<your-api-key>", // Required (or set MEMBIT_API_KEY env var)
  apiBaseURL: "https://custom.api", // Optional (defaults to Membit API)
});

// All methods support these options (showing defaults)
const result = await client.cluster_search("query", {
  limit: 10, // number (default: 10)
  format: "json", // "json" | "llm" (default: "json")
  timeout: 60, // seconds (default: 60)
});
```

### Default Parameters

All search methods use these defaults when options are not specified:

* **limit**: 10 — Maximum number of results to return
* **format**: "json" — Return structured data as objects
* **timeout**: 60 — Request timeout in seconds

## Environment Variables

You can set your API key via environment variable:

```bash theme={null}
export MEMBIT_API_KEY="<your-api-key>"
```

If `apiKey` is not provided in the client options, the SDK will automatically use `MEMBIT_API_KEY`.

## Examples

See [`membit-js`](https://github.com/bandprotocol/membit-js)'s `examples/` directory for more comprehensive usage:

* `examples/basic-usage.ts` — Complete workflow with realistic API usage


# Billing & Cost
Source: https://docs.membit.ai/billing-and-cost

Understand Membit's pricing, plans, and API credit system.

Membit is designed to be accessible and scalable. Our pricing is built on a simple, developer-friendly credit system that ensures you only pay for the value you receive.

## API Credit System

To align cost with value, different API calls are weighted based on the complexity and insight they provide. This means you can make lots of lightweight calls without worrying about running up a big bill.

<CardGroup>
  <Card title="clusters_search" icon="chart-network">
    **Cost:** 3 credits
  </Card>

  <Card title="clusters_info" icon="chart-scatter-bubble">
    **Cost:** 2 credits
  </Card>

  <Card title="posts_search" icon="magnifying-glass">
    **Cost:** 1 credit
  </Card>
</CardGroup>

## Generous Free Beta

<Note>
  During our beta period, we're excited to offer a generous free plan to help
  you get started.

  * **Initial Credits:** Every new user receives **500 API credits** upon
    signing up.
  * **Daily Refresh:** Your account is topped up with an additional **100 API
    credits** every day.

  Need more? If you have a high-volume use case or need a custom data pipeline,
  please [contact us on Discord](https://discord.bandprotocol.com). We're happy to
  discuss your needs.
</Note>


# Browser Extension
Source: https://docs.membit.ai/data-hunters/browser-extension

Become a Data Hunter and contribute to Membit's real-time context.

Anyone can become a contributor to Membit's data pool by installing the Membit browser extension. As a Data Hunter, you'll play a crucial role in helping us build the world's most relevant real-time context engine.

<img alt="Cover Image" />

## How it Works

The Membit browser extension allows you to contribute public social posts to our data pool. Here's how to get started:

<Steps>
  <Step title="Install the Extension">
    You can download the Membit extension from the [Google Chrome Web
    Store](https://chromewebstore.google.com/detail/membit-data-hunters-beta/fcjoldoebodoljbljpnkdnfgnpdgbdcm).
  </Step>

  <Step title="Sign in with X">
    To get started, you'll need to sign in with your X (formerly Twitter)
    account. This allows us to attribute your contributions and reward you with
    points.
  </Step>

  <Step title="Browse Social Media">
    The extension currently supports X, Farcaster, and Bluesky. As you browse
    these platforms, the extension will automatically digest the public posts
    you're seeing and report them to our servers.
  </Step>

  <Step title="Earn Rewards">
    Every epoch (which happens every 60 minutes), your contributions are
    rewarded in Points. These points can be redeemed for various rewards in the
    future.
  </Step>
</Steps>

<Note>
  The Membit browser extension only has access to public posts. No private
  posts, personal data, or messages are ever accessed or shared.
</Note>


# Data Privacy & Compliance
Source: https://docs.membit.ai/data-hunters/data-privacy-and-compliance

Learn about our commitment to data privacy and compliance.

We are committed to protecting the privacy of our Data Hunters and ensuring that our platform is compliant with all relevant regulations.

The Data Hunter chrome extension acts as an automated tool for hunters to contribute **public social posts** they are viewing to Membit. This is similar to how your browsing history might be used to personalize advertising, but instead of serving ads, we use this data to make AI agents smarter and more useful for everyone.

<Note>
  Only publicly available posts are shared with Membit. **No private posts,
  personal data, or direct messages are ever accessed or shared.** We are
  committed to ensuring the privacy and security of our users' data.
</Note>


# Leaderboard
Source: https://docs.membit.ai/data-hunters/leaderboard

Track your progress and see how you stack up against other Data Hunters.

You can view the Data Hunter leaderboard at [hunter.membit.ai/leaderboard](https://hunter.membit.ai/leaderboard). The leaderboard showcases the top Data Hunters and their point totals.

<Info>
  If you prefer to remain anonymous, you can anonymize your account on the
  leaderboard through the settings in the browser extension.
</Info>


# Point Redemption
Source: https://docs.membit.ai/data-hunters/point-redemption

Learn how you'll be able to redeem your points for rewards.

The ability to redeem points is coming soon! We're working on a variety of ways for you to use your points, from API credits to exclusive merchandise.

<Info>Stay tuned for more updates on our point redemption program.</Info>


# Reward Calculation
Source: https://docs.membit.ai/data-hunters/reward-calculation

Learn how points are calculated and awarded to Data Hunters.

Your curiosity deserves to be rewarded. As a Data Hunter, you earn points every epoch (every 60 minutes) based on the quality and impact of the content you share. Here’s a breakdown of how you can maximize your earnings.

## How Your Points Are Calculated

Membit rewards posts with multiple qualities:

<CardGroup>
  <Card title="Engagement" icon="arrow-up-right-dots">
    The more a post resonates with the community (think likes, replies, and
    shares), the more points it’s worth. High-engagement content is highly
    valued.
  </Card>

  <Card title="Uniqueness" icon="gem">
    Be the first to spot a gem. If multiple Data Hunters report the same post,
    the points are shared. To maximize your rewards, focus on sharing unique,
    high-quality content that others might miss.
  </Card>

  <Card title="Timeliness" icon="clock">
    The world moves fast, and so should you. The newer a post is, the more
    points you'll earn for discovering it.
  </Card>

  <Card title="Relevancy" icon="check">
    Your contributions help build a clearer picture of what's happening. Points
    are awarded for posts that are grouped into a larger trend or topic (a
    cluster), ensuring every piece of data adds meaningful context.
  </Card>
</CardGroup>

## Grow Your Earning Potential

We believe in rewarding consistent, high-quality contributions. Every Data Hunter starts with an earning cap of **10,000 points** per epoch (every 60 minutes).

When you hit your cap, we raise it for the next epoch, allowing you to earn even more. Keep contributing great content, and you can grow your cap up to a maximum of **200,000 points** per epoch—that's 20 times the starting potential! It's our way of saying thanks for being an active part of the membit community.


# How Membit Works
Source: https://docs.membit.ai/how-membit-works

Learn about the data pipeline that powers Membit's real-time context.

Membit's power comes from a sophisticated data pipeline that transforms raw, user-generated content into structured, high-signal context for AI agents. This process involves a unique combination of human curation and automated processing.

<Steps>
  <Step title="Step 1: Data Hunters Contribute Content">
    <img alt="Data Hunters Contribute Content" />

    The process begins with our global network of **Data Hunters**. Using a browser
    extension, they capture relevant social media posts, news articles, and other
    online content as they browse. This human-in-the-loop approach ensures that we
    are sourcing content that is genuinely interesting and significant.
  </Step>

  <Step title="Step 2: Verification and Filtering">
    <img alt="Verification and Filtering" />

    Once submitted, the raw data enters our distributed infrastructure for validation.
    Automated checks and AI classifiers work to filter out spam, duplicates, and
    irrelevant content. This ensures that only high-quality, timely information proceeds
    to the next stage.
  </Step>

  <Step title="Step 3: Clustering and Analysis">
    <img alt="Clustering and Analysis" />

    The verified posts are then transformed into vector embeddings. An unsupervised
    clustering algorithm groups semantically related posts into "discussion clusters,"
    representing distinct narrative themes. We also apply a time-decayed engagement
    score to prioritize the most active and relevant conversations.
  </Step>

  <Step title="Step 4: API Delivery">
    <img alt="API Delivery" />

    The final, structured context is made available through our developer-friendly
    API. AI developers can easily integrate this real-time data feed into their applications
    using our RESTful endpoints or the Model Context Protocol (MCP) server.
  </Step>
</Steps>


# Welcome
Source: https://docs.membit.ai/index

Equip your AI agents with real-time context of global conversations.

<img alt="Cover Image" />

## Real-time Context for AI

Membit provides your AI agents with a direct line to the world's real-time conversations. Our **Context-as-a-Service (CaaS)** platform delivers a continuously updated, ready-to-use knowledge base sourced from global social discussions.

We empower developers and AI agent builders to overcome the limitations of static datasets, ensuring your applications are always equipped with the most current and relevant information.

## Get Started

<CardGroup>
  <Card title="How Membit Works" icon="microchip" href="/how-membit-works">
    Learn about the architecture that powers our real-time data engine.
  </Card>

  <Card title="Get Your API Key" icon="key" href="/access-and-auth">
    Get your API key and start building in minutes.
  </Card>

  <Card title="Explore Use Cases" icon="sparkle" href="/use-cases">
    Discover what you can build with Membit's real-time context.
  </Card>

  <Card title="Become a Data Hunter" icon="user-plus" href="/data-hunters/browser-extension">
    Join our community and get rewarded for contributing to a smarter AI.
  </Card>
</CardGroup>

## See Membit in Action

<Card title="Try the Membit ChatGPT Agent" icon="robot" href="https://chatgpt.membit.ai/">
  See Membit in action with ChatGPT enhanced with real-time context from Membit.
  Experience how current conversations and trends can transform AI interactions.
</Card>

<Card title="Try the API Playground" icon="play" href="/playground/search-clusters">
  Get hands-on with our API. Make live queries and see the data structure for
  yourself in our interactive playground. No setup required.
</Card>

<Card title="Explore Live Data" icon="globe" href="https://membit.ai">
  See what's trending in real-time with our Live Cluster Explorer. This
  interactive visualization showcases the latest topics and conversations being
  surfaced by our global community of Data Hunters.
</Card>

## Start Building with Membit

Ready to give your AI agents the context they need? Choose your preferred integration method and start building smarter applications today.

<Tip>
  New to Membit? Start with our [MCP Server](/api-usage/mcp-server) for the
  fastest setup, or try our [API Playground](/api-reference/search-clusters) to
  explore the data structure first.
</Tip>

<CardGroup>
  <Card title="MCP Server" icon="https://mintcdn.com/membit/_tmJJKYeIoHuBpSM/images/icons/mcp.svg?fit=max&auto=format&n=_tmJJKYeIoHuBpSM&q=85&s=75c4efec0cc9b07f1862683bca5865d6" href="/api-usage/mcp-server" />

  <Card title="Python" icon="https://mintcdn.com/membit/_tmJJKYeIoHuBpSM/images/icons/python.svg?fit=max&auto=format&n=_tmJJKYeIoHuBpSM&q=85&s=7b47175181bef64ed6da6821a8d8589c" href="/api-usage/python" />

  <Card title="TypeScript" icon="https://mintcdn.com/membit/X3g2jASQcla7cFkX/images/icons/typescript.svg?fit=max&auto=format&n=X3g2jASQcla7cFkX&q=85&s=3a7b1e2dda94ffa463210129517453e3" href="/api-usage/typescript" />

  <Card title="n8n" icon="https://mintcdn.com/membit/_tmJJKYeIoHuBpSM/images/icons/n8n.svg?fit=max&auto=format&n=_tmJJKYeIoHuBpSM&q=85&s=017ac79fcfce4aff6ff6f17ac1cd5f87" href="/integrations/no-code-agent-frameworks/n8n" />

  <Card title="Gumloop" icon="https://mintcdn.com/membit/X3g2jASQcla7cFkX/images/icons/gumloop.svg?fit=max&auto=format&n=X3g2jASQcla7cFkX&q=85&s=e74d0950d0e30786a8f335f6cc2939b7" href="/integrations/no-code-agent-frameworks/gumloop" />

  <Card title="Flowise" icon="https://mintcdn.com/membit/X3g2jASQcla7cFkX/images/icons/flowise.png?fit=max&auto=format&n=X3g2jASQcla7cFkX&q=85&s=1bebb0c9d366834a9bb0651dd8481ed4" href="/integrations/no-code-agent-frameworks/flowise" />

  <Card title="Langflow" icon="https://mintcdn.com/membit/X3g2jASQcla7cFkX/images/icons/langflow.svg?fit=max&auto=format&n=X3g2jASQcla7cFkX&q=85&s=54d0f8419cc7d57c91348662c2c1f10f" href="/integrations/no-code-agent-frameworks/langflow" />

  <Card title="Cursor" icon="https://mintcdn.com/membit/X3g2jASQcla7cFkX/images/icons/cursor.png?fit=max&auto=format&n=X3g2jASQcla7cFkX&q=85&s=1d0bb3cb5c997a0190c790065d436d97" href="/integrations/no-code-agent-frameworks/cursor" />

  <Card title="CrewAI" icon="https://mintcdn.com/membit/X3g2jASQcla7cFkX/images/icons/crewai.svg?fit=max&auto=format&n=X3g2jASQcla7cFkX&q=85&s=94a0e8a1d068e44402d24037f6795015" href="/integrations/python-agent-framework/crewai" />

  <Card title="LangChain" icon="https://mintcdn.com/membit/X3g2jASQcla7cFkX/images/icons/langchain.svg?fit=max&auto=format&n=X3g2jASQcla7cFkX&q=85&s=b79ac8dd2df0786a72f7797736ebb893" href="/integrations/python-agent-framework/langchain" />

  <Card title="LlamaIndex" icon="https://mintcdn.com/membit/X3g2jASQcla7cFkX/images/icons/llamaindex.png?fit=max&auto=format&n=X3g2jASQcla7cFkX&q=85&s=d05931965edaf5b6aa90acb6762485bf" href="/integrations/python-agent-framework/llamaindex" />

  <Card title="Autogen" icon="https://mintcdn.com/membit/4JB7OCBLDkpjkRT-/images/icons/autogen.png?fit=max&auto=format&n=4JB7OCBLDkpjkRT-&q=85&s=4f2061f43f2c9a23df6fe0eaf9939540" href="/integrations/python-agent-framework/autogen" />

  <Card title="Mastra" icon="https://mintcdn.com/membit/_tmJJKYeIoHuBpSM/images/icons/mastra.svg?fit=max&auto=format&n=_tmJJKYeIoHuBpSM&q=85&s=a297296c6e53a5a95b34d22a0270e145" href="/integrations/typescript-agent-framework/mastra" />

  <Card title="Voltagent" icon="https://mintcdn.com/membit/X3g2jASQcla7cFkX/images/icons/voltagent.png?fit=max&auto=format&n=X3g2jASQcla7cFkX&q=85&s=30300873f656c529c81701661d25cf1e" href="/integrations/typescript-agent-framework/voltagent" />
</CardGroup>

## Join Our Community

Have questions or want to stay up-to-date? Join the conversation on our community channels.

<CardGroup>
  <Card title="Join our Discord" icon="discord" href="https://discord.bandprotocol.com">
    Chat with the team, get support, and connect with other developers.
  </Card>

  <Card title="Follow us on X" icon="twitter" href="https://x.com/membit_ai">
    Stay in the loop with the latest updates, announcements, and featured
    insights.
  </Card>
</CardGroup>


# Claude Desktop
Source: https://docs.membit.ai/integrations/no-code-agent-frameworks/claude

Integrate real-time context to your Claude Desktop via Membit MCP.

Claude Desktop supports custom MCP integrations (currently in beta). By connecting Membit, you give Claude access to real-time social context—so it can answer with what's happening now across the web.

## Prerequisites

Before you begin, make sure you have:

* Claude Desktop installed (macOS or Windows)
* A Membit account with an API key [get your API key](/access-and-auth)
* Basic familiarity with editing configuration files

## Set up Membit Remote MCP

Follow these steps to enable the Membit MCP server in Claude Desktop:

<Steps>
  <Step title="Create or open the Claude config file">
    Use the correct path for your OS.

    <Tabs>
      <Tab title="macOS">
        ```bash theme={null}
        nano ~/Library/Application\ Support/Claude/claude_desktop_config.json
        ```
      </Tab>

      <Tab title="Windows">
        ```powershell theme={null}
        notepad C:\Users\%USERNAME%\AppData\Roaming\Claude\claude_desktop_config.json
        ```
      </Tab>
    </Tabs>

    <Tip>
      If the file doesn't exist, these commands will create it when you save.
    </Tip>
  </Step>

  <Step title="Add the Membit MCP configuration">
    Paste the following JSON into `claude_desktop_config.json`:

    ```json theme={null}
    {
      "mcpServers": {
        "membit-remote-mcp": {
          "command": "npx",
          "args": [
            "-y",
            "mcp-remote",
            "https://mcp.membit.ai/mcp",
            "--header",
            "X-Membit-Api-Key:${API_KEY}"
          ],
          "env": {
            "API_KEY": "<your-api-key>"
          }
        }
      }
    }
    ```

    <Warning>
      Replace `<your-api-key>` with your actual Membit API key. Keep this credential secure and never share it publicly.
    </Warning>

    <Check>
      Validate your JSON: ensure quotes are correct and there are no trailing commas.
    </Check>
  </Step>

  <Step title="Restart Claude Desktop">
    Completely quit and reopen Claude Desktop to load the new MCP configuration.
  </Step>

  <Step title="Verify the integration">
    Open Claude and confirm the Membit MCP tools are available.

    <Frame>
      <img alt="Claude Desktop showing Membit MCP tools available" />
    </Frame>

    <Check>
      You should see Membit tools available for use when Claude performs tool calls.
    </Check>
  </Step>
</Steps>

## Use Membit with Claude

Now that the integration is set, try a chat enhanced with real-time context:

<Steps>
  <Step title="Start a new chat in Claude">
    Open Claude Desktop and begin a conversation.
  </Step>

  <Step title="Ask context-aware questions">
    Try prompts that benefit from up-to-the-minute context:

    * "What's trending in AI today?"
    * "Summarize the latest crypto news from real conversations"
    * "What are people discussing about \[your topic] right now?"

    <Note>
      Claude may ask to run tools—allow tool usage so it can call the Membit MCP.
    </Note>

    <Frame>
      <img alt="Claude chat showing responses with real-time context" />
    </Frame>

    <Check>
      Responses should include timely insights sourced from current public conversations.
    </Check>
  </Step>
</Steps>

## Troubleshooting

<AccordionGroup>
  <Accordion title="Config file not detected">
    **Problem**: Claude doesn't load the MCP configuration.

    **Solutions**:

    * Verify the file path is exact for your OS:
      * macOS: `~/Library/Application Support/Claude/claude_desktop_config.json`
      * Windows: `C:\\Users\\%USERNAME%\\AppData\\Roaming\\Claude\\claude_desktop_config.json`
    * Ensure Claude Desktop was fully restarted after edits
    * Confirm the file encoding is UTF-8 without BOM
  </Accordion>

  <Accordion title="JSON syntax errors">
    **Problem**: Configuration fails to parse.

    **Solutions**:

    * Validate JSON with an online linter
    * Remove trailing commas and ensure double quotes are used
    * Confirm braces and brackets are properly matched
  </Accordion>

  <Accordion title="API key authentication fails">
    **Problem**: Membit tools show auth errors.

    **Solutions**:

    * Ensure `env.API_KEY` contains your exact Membit API key
    * Confirm the header name is `X-Membit-Api-Key` (case-sensitive)
    * Regenerate your API key in Membit if issues persist
  </Accordion>

  <Accordion title="Membit tools not appearing">
    **Problem**: Tools don't show up in Claude.

    **Solutions**:

    * Double-check the `mcpServers` object name and structure
    * Ensure `npx` is available on your system PATH
    * Try adding `-y` to `npx` args (already included above)
    * Restart Claude after any config changes
  </Accordion>

  <Accordion title="Claude won't run tools">
    **Problem**: Claude replies without using the MCP.

    **Solutions**:

    * Make prompts more explicit: "Use the available tools to check what's happening now about..."
    * Allow tool usage when prompted in the chat
    * Ask about timely topics that require fresh context
  </Accordion>
</AccordionGroup>


# Cursor
Source: https://docs.membit.ai/integrations/no-code-agent-frameworks/cursor

Integrate real-time context to your Cursor AI Code Editor via Membit MCP.

<img alt="Cover Image" />

Cursor is an AI-powered code editor that enhances your development workflow with intelligent assistance. By integrating Membit with Cursor, you can access real-time social context directly within your coding environment, enabling your AI assistant to provide up-to-date insights about trending topics, current discussions, and breaking news while you work.

## Prerequisites

Before you begin, make sure you have:

* Cursor editor installed ([download here](https://cursor.com))
* A Membit account with an API key [get your API key](/access-and-auth)
* Basic familiarity with Cursor's interface and AI features

## Setting Up Membit MCP Integration

Follow these steps to integrate Membit with your Cursor environment:

<Steps>
  <Step title="Access Cursor Settings">
    Open Cursor and navigate to the settings by clicking on the settings icon or using the keyboard shortcut.

    <Frame>
      <img alt="Cursor settings interface showing configuration options" />
    </Frame>
  </Step>

  <Step title="Navigate to Tools & Integrations">
    In the settings menu, locate and click on **Tools & Integrations** to access external service configurations.

    <Frame>
      <img alt="Cursor tools and integrations settings page" />
    </Frame>

    <Check>
      The Tools & Integrations section allows you to connect external services and tools to enhance Cursor's capabilities.
    </Check>
  </Step>

  <Step title="Add Custom MCP">
    Click **Add Custom MCP** to create a new Model Context Protocol integration.
  </Step>

  <Step title="Configure Membit Remote MCP">
    Paste the following Membit remote MCP configuration into the configuration field:

    ```json theme={null}
    {
      "mcpServers": {
        "membit-mcp": {
          "url": "https://mcp.membit.ai/mcp",
          "headers": {
            "X-Membit-Api-Key": <your-api-key>
          }
        }
      }
    }
    ```

    <Warning>
      Replace `<your-api-key>` with your actual Membit API key. Keep this credential secure and don't share it with unauthorized users.
    </Warning>

    **Configuration Details:**

    * **Server Name**: `membit-remote-mcp`
    * **Command**: Uses npx to run the remote MCP client
    * **Environment**: Empty object for default environment variables
  </Step>

  <Step title="Enable Membit Remote MCP">
    After saving the configuration, turn on the **Membit Remote MCP** tool to activate the integration.

    <Frame>
      <img alt="Cursor interface showing how to enable Membit Remote MCP tool" />
    </Frame>

    <Check>
      Once enabled, Cursor's AI will have access to Membit's real-time context capabilities when processing your requests.
    </Check>
  </Step>
</Steps>

## Using Membit with Cursor

Now that the integration is set up, you can start using Membit's real-time context in your development workflow:

<Steps>
  <Step title="Start a Chat Session">
    Open Cursor's chat interface and begin a conversation with the AI assistant.
  </Step>

  <Step title="Ask Context-Aware Questions">
    Try asking questions that benefit from real-time context:

    * "What are the latest trends in web development?"
    * "Tell me about recent discussions in the AI community"
    * "What's currently trending in cryptocurrency?"
    * "Give me insights on the latest tech news"

    <Note>
      When Cursor asks for permission to run tools, click **Run Tool** to allow
      access to Membit's real-time data. Cursor requests permission every time it
      uses external tools. You can bypass these permission prompts by adjusting the
      tool permissions in Cursor settings if desired.
    </Note>

    <Frame>
      <img alt="Cursor chat interface showing conversation with real-time context from Membit" />
    </Frame>

    <Check>
      Your AI assistant will now provide responses enhanced with current, real-world context from Membit's data feed.
    </Check>
  </Step>
</Steps>

## Troubleshooting

<AccordionGroup>
  <Accordion title="Custom MCP Configuration Issues">
    **Problem**: Custom MCP configuration fails to load or save

    **Solutions**:

    Verify the JSON configuration syntax is valid (no trailing commas, proper quotes)

    Ensure the server name `membit-mcp` is unique and not conflicting

    Check that the URL is exactly `https://mcp.membit.ai/mcp`

    Try restarting Cursor after configuration changes

    Validate the JSON structure matches the required format exactly
  </Accordion>

  <Accordion title="API Key Authentication Problems">
    **Problem**: Membit API key authentication is failing

    **Solutions**:

    Verify your API key is correctly placed in the headers configuration

    Ensure the header name is exactly `X-Membit-Api-Key` (case-sensitive)

    Check that there are no extra spaces or characters around the API key

    Confirm your Membit API key is active and has sufficient credits

    Try generating a new API key if the current one isn't working
  </Accordion>

  <Accordion title="Tool Permission Prompts">
    **Problem**: Cursor keeps asking for permission to run tools

    **Solutions**:

    Click "Run Tool" when prompted to allow Membit access for that session

    Go to Cursor settings → Tools & Integrations → adjust tool permissions

    Enable "Auto-approve safe tools" if available in your Cursor version

    Consider the security implications before disabling permission prompts

    Use "Always allow" option when prompted if you trust the Membit integration
  </Accordion>

  <Accordion title="MCP Server Not Responding">
    **Problem**: Cursor can't connect to Membit MCP server

    **Solutions**:

    Check your internet connection and firewall settings

    Verify the Membit MCP server is operational (try accessing the URL in browser)

    Ensure Cursor has network access permissions on your system

    Try toggling the MCP integration off and on again

    Check Cursor's console/logs for specific error messages
  </Accordion>

  <Accordion title="AI Assistant Not Using Membit Tools">
    **Problem**: Chat responses don't include real-time context

    **Solutions**:

    Make requests more explicit: "Use Membit to find current information about..."

    Verify the Membit Remote MCP tool is enabled and active

    Check that your questions relate to topics likely to have recent social media discussion

    Try asking about trending topics that would benefit from real-time context

    Ensure you're allowing tool usage when Cursor requests permission
  </Accordion>
</AccordionGroup>


# Flowise
Source: https://docs.membit.ai/integrations/no-code-agent-frameworks/flowise

Integrate real-time context to your Flowise chatflows via Membit MCP.

<img alt="Cover Image" />

Flowise is a visual low-code platform for building AI-powered chatflows and agents. By integrating Membit with Flowise, you can enhance your AI agents with real-time social context, enabling them to access current trends, breaking news, and live conversations from across the web through a visual drag-and-drop interface.

## Prerequisites

Before you begin, make sure you have:

* An active Flowise instance (cloud or self-hosted)
* A Membit account with an API key [get your API key](/access-and-auth)
* Basic familiarity with Flowise's visual workflow builder
* A Google AI Studio API key for the chat model (optional)

## Setting Up Membit Custom MCP

Follow these steps to integrate Membit with your Flowise chatflows:

<Steps>
  <Step title="Access Chatflows">
    Navigate to your Flowise dashboard and click **Chatflows** in the menu bar to access the workflow builder.

    <Frame>
      <img alt="Flowise dashboard showing chatflows menu option" />
    </Frame>
  </Step>

  <Step title="Create New Chatflow">
    Click **Add New** to start building a new chatflow from scratch.

    <Frame>
      <img alt="Flowise add new chatflow button" />
    </Frame>
  </Step>

  <Step title="Add Node Panel">
    Click **Add Node** in the top left corner to open the node library.

    <Frame>
      <img alt="Flowise add node button in workflow editor" />
    </Frame>
  </Step>

  <Step title="Search for Custom MCP">
    In the node search bar, type "Custom MCP" to find the Model Context Protocol integration node.

    <Frame>
      <img alt="Searching for Custom MCP node in Flowise node library" />
    </Frame>

    <Check>
      The Custom MCP node enables Flowise to connect with external MCP servers like Membit, providing real-time context to your chatflows.
    </Check>
  </Step>

  <Step title="Configure Custom MCP Node">
    Drag and drop the **Custom MCP** node to your chatflow board, then configure it with your Membit server details.

    <Frame>
      <img alt="Custom MCP node configuration interface in Flowise" />
    </Frame>

    **MCP Server Configuration:**
    Set the configuration using JSON format and replace with your Membit API key:

    ```json theme={null}
    {
      "url": "https://mcp.membit.ai/mcp",
      "headers": {
        "X-Membit-Api-Key": "{{$vars.MEMBIT_API_KEY}}"
      }
    }
    ```

    <Warning>
      To use your API key securely, create a `MEMBIT_API_KEY` variable in Flowise
    </Warning>

    After configuration, click the **refresh button** to load available actions, then select the actions you want to use.
  </Step>
</Steps>

## Building Your First Chatflow

Now let's create a complete chatflow that uses Membit's real-time context:

<Steps>
  <Step title="Add Chat Model">
    Search for and add a **ChatGoogleGenerativeAI** node to handle the conversational AI.

    <Frame>
      <img alt="Searching for ChatGoogleGenerativeAI node in Flowise" />
    </Frame>

    **Configuration:**

    * Set up your Google AI Studio API key credential
    * Select your preferred model (e.g., Gemini Pro)

    <Frame>
      <img alt="ChatGoogleGenerativeAI node configuration in Flowise" />
    </Frame>
  </Step>

  <Step title="Add Tool Agent">
    Search for and add a **Tool Agent** node to coordinate between the chat model and external tools.

    <Frame>
      <img alt="Searching for Tool Agent node in Flowise" />
    </Frame>

    <Check>
      The Tool Agent acts as the orchestrator, managing how your chat model interacts with external tools like Membit.
    </Check>
  </Step>

  <Step title="Add Buffer Memory">
    Search for and add a **Buffer Memory** node to maintain conversation context.

    <Frame>
      <img alt="Searching for Buffer Memory node in Flowise" />
    </Frame>
  </Step>

  <Step title="Connect the Nodes">
    Connect all the nodes to create a functioning chatflow:

    <Frame>
      <img alt="Connected Flowise chatflow showing all nodes linked together" />
    </Frame>

    **Connection Pattern:**

    * **Custom MCP** → **Tools** (Tool Agent)
    * **ChatGoogleGenerativeAI** → **Tool Calling Chat Model** (Tool Agent)
    * **Buffer Memory** → **Memory** (Tool Agent)

    <Tip>
      The visual connections show the data flow - the Tool Agent receives tools from Custom MCP, uses the chat model for responses, and maintains memory for context.
    </Tip>
  </Step>

  <Step title="Test Your Chatflow">
    Once all nodes are connected, test your chatflow by starting a conversation.

    <Frame>
      <img alt="Flowise chat interface showing conversation with real-time context" />
    </Frame>

    <Check>
      Try asking questions like "What's trending in AI today?" or "Tell me about recent crypto news" to see Membit's real-time context in action.
    </Check>
  </Step>
</Steps>

## Troubleshooting

<AccordionGroup>
  <Accordion title="Custom MCP Configuration Issues">
    **Problem**: Cannot configure or connect Custom MCP node

    **Solutions**:

    Verify the JSON configuration syntax is valid (no trailing commas, proper quotes)

    Ensure the URL is exactly `https://mcp.membit.ai/mcp`

    Check that the `MEMBIT_API_KEY` variable is properly set in Flowise

    Try clicking the refresh button after configuration to load available actions

    Restart Flowise after making configuration changes
  </Accordion>

  <Accordion title="Environment Variable Problems">
    **Problem**: API key variable not recognized in Flowise

    **Solutions**:

    Create a `MEMBIT_API_KEY` variable in Flowise's environment settings

    Ensure the variable syntax in JSON uses `{{$vars.MEMBIT_API_KEY}}`

    Verify there are no extra spaces or characters in the variable name

    Check that your Membit API key is active and valid

    Try restarting Flowise completely after setting environment variables
  </Accordion>

  <Accordion title="Tool Agent Connection Issues">
    **Problem**: Tool Agent doesn't connect to Custom MCP properly

    **Solutions**:

    Ensure Custom MCP is connected to the "Tools" input of Tool Agent

    Verify ChatGoogleGenerativeAI is connected to "Tool Calling Chat Model" input

    Check that Buffer Memory is connected to "Memory" input

    Confirm all connection lines are properly established and visible

    Try disconnecting and reconnecting nodes in the correct sequence
  </Accordion>

  <Accordion title="Chat Model Not Using Tools">
    **Problem**: AI responses don't include real-time context from Membit

    **Solutions**:

    Verify the Google AI Studio API key is correctly configured

    Ensure the chat model supports function calling (Gemini Pro recommended)

    Make prompts more explicit: "Use available tools to search for current information about..."

    Check that the Custom MCP actions are properly loaded and selected

    Test with topics that are likely to have recent social media activity
  </Accordion>

  <Accordion title="Chatflow Execution Errors">
    **Problem**: Chatflow fails to execute or times out

    **Solutions**:

    Check all required inputs are connected and configured

    Verify internet connectivity and firewall settings

    Ensure your Google AI Studio API key has sufficient quota

    Review Flowise logs for specific error messages

    Try testing individual components before connecting the full flow
  </Accordion>
</AccordionGroup>


# Gumloop
Source: https://docs.membit.ai/integrations/no-code-agent-frameworks/gumloop

Integrate real-time context to your Gumloop AI workflows via Membit MCP.

<img alt="Cover Image" />

<Warning>
  **Current Integration Issue**: There are currently limitations with setting
  custom headers in the Gumloop MCP server configuration, which may prevent
  proper authentication with Membit's API. We are working to resolve this issue.
</Warning>

Gumloop is an intuitive no-code platform that enables you to build AI-powered workflows and automations. By integrating Membit with Gumloop, you can enhance your AI agents with real-time social context, allowing them to access current trends, breaking news, and live conversations from across the web.

## Prerequisites

Before you begin, make sure you have:

* An active Gumloop account ([sign up here](https://gumloop.com))
* A Membit account with an API key [get your API key](/access-and-auth)
* Basic familiarity with Gumloop's workflow builder

## Setting Up Membit MCP Server

Follow these steps to integrate Membit with your Gumloop workflows:

<Steps>
  <Step title="Access Settings">
    Navigate to your Gumloop dashboard and click on the **Settings** option in the main menu.

    <Frame>
      <img alt="Gumloop dashboard with settings menu highlighted" />
    </Frame>
  </Step>

  <Step title="Go to Personal Credentials">
    In the settings menu, locate and click on **Personal Credentials** to manage your external service connections.

    <Frame>
      <img alt="Gumloop settings page showing personal credentials section" />
    </Frame>
  </Step>

  <Step title="Add New Credentials">
    Click the **Add Credentials** button to create a new credential set for external services.

    <Frame>
      <img alt="Add credentials button in Gumloop personal credentials page" />
    </Frame>
  </Step>

  <Step title="Search for MCP Server">
    In the credential type search, type "MCP server" and select the **MCP Server** option when it appears.

    <Frame>
      <img alt="Searching for MCP server in Gumloop credentials options" />
    </Frame>

    <Check>
      The MCP Server credential type enables Gumloop to connect with external Model Context Protocol servers like Membit.
    </Check>
  </Step>

  <Step title="Configure MCP Server Settings">
    Fill in the MCP server configuration with the following details:

    ```
    URL: https://mcp.membit.ai/mcp
    Label: membit-mcp
    Additional Header: X-Membit-Api-Key: <your-api-key>
    ```

    <Frame>
      <img alt="MCP server configuration form in Gumloop with URL and label fields" />
    </Frame>

    <Warning>
      Replace `<your-api-key>` with your actual Membit API key. Keep this credential secure and don't share it with unauthorized users.
    </Warning>

    Click **Save** to store your MCP server credentials.
  </Step>
</Steps>

## Building Your First Workflow

Now that your Membit MCP server is configured, let's create a workflow that uses real-time context:

<Steps>
  <Step title="Navigate to the Hub">
    Go to the **Hub** section in your Gumloop dashboard to access the workflow builder.

    <Frame>
      <img alt="Gumloop hub interface showing available workflow options" />
    </Frame>
  </Step>

  <Step title="Create New Flow">
    Click **Create Flow** to start building a new workflow from scratch.
  </Step>

  <Step title="Add Your First Node">
    Click **Add your first node** to begin building your workflow logic.

    <Frame>
      <img alt="Gumloop workflow builder showing add first node option" />
    </Frame>
  </Step>

  <Step title="Search for Ask AI">
    In the node search bar, type "Ask AI" to find the AI conversation node.

    <Frame>
      <img alt="Searching for Ask AI node in Gumloop node library" />
    </Frame>
  </Step>

  <Step title="Configure Ask AI Node">
    Select the **Ask AI** node and configure it with these settings:

    <Frame>
      <img alt="Ask AI node configuration interface in Gumloop" />
    </Frame>

    **Basic Configuration:**

    * **Prompt**: "Tell me about crypto news using membit" (or your preferred query)
    * **AI Model**: Choose "Claude 4 Sonnet" or your preferred model

    <Frame>
      <img alt="Ask AI node options showing MCP server connection settings" />
    </Frame>

    **Advanced Options:**

    1. Click **"Show more options"**
    2. Set **"Connect MCP server"** to **Yes**
    3. Choose **MCP servers**: Select the "membit-mcp" you created earlier
  </Step>

  <Step title="Test Your Workflow">
    Click **Run** to execute your workflow and see Membit's real-time context in action.

    <Frame>
      <img alt="Gumloop workflow execution results showing AI response with real-time context" />
    </Frame>

    <Check>
      If successful, your AI agent will respond with current information about your query topic, powered by Membit's real-time data feed.
    </Check>
  </Step>
</Steps>

## Troubleshooting

<AccordionGroup>
  <Accordion title="MCP Server Connection Issues">
    **Problem**: Cannot connect to Membit MCP server in Gumloop

    **Solutions**:

    Verify the MCP server URL is correct: `https://mcp.membit.ai/mcp`

    Check your API key is correct and active

    Ensure the Additional Header format is exact: `X-Membit-Api-Key: <your-api-key>`

    Try re-saving the MCP server credentials

    Check if Gumloop has proper internet access
  </Accordion>

  <Accordion title="Authentication Failures">
    **Problem**: API key authentication is failing

    **Solutions**:

    Verify your Membit API key is active in your dashboard

    Ensure there are no extra spaces or characters in the API key

    Check that the header name is exactly `X-Membit-Api-Key` (case-sensitive)

    Try generating a new API key if the current one isn't working

    Confirm your Membit account has sufficient credits/usage allowance
  </Accordion>

  <Accordion title="Ask AI Node Configuration">
    **Problem**: Ask AI node doesn't use Membit tools

    **Solutions**:

    Ensure "Connect MCP server" is set to **Yes**

    Verify the "membit-mcp" server is selected in MCP servers dropdown

    Try switching to Claude 4 Sonnet model for better tool usage

    Make your prompt more explicit about using Membit: "Use membit to tell me about..."

    Check if the workflow has proper permissions to access external servers
  </Accordion>
</AccordionGroup>


# Langflow
Source: https://docs.membit.ai/integrations/no-code-agent-frameworks/langflow

Integrate real-time context to your LangFlow AI workflows via Membit MCP.

<img alt="Cover Image" />

Langflow is a visual framework for building multi-agent and RAG applications using a drag-and-drop interface. By integrating Membit with Langflow, you can enhance your AI agents with real-time social context, enabling them to access current trends, breaking news, and live conversations from across the web through a node-based visual workflow.

## Prerequisites

Before you begin, make sure you have:

* Langflow application installed ([download here](https://langflow.org))
* A Membit account with an API key [get your API key](/access-and-auth)
* Basic familiarity with Langflow's visual workflow builder
* A Google AI Studio API key for the chat model (optional)

## Setting Up Membit MCP Tools

Follow these steps to integrate Membit with your Langflow workflows:

<Steps>
  <Step title="Create New Flow">
    Open the Langflow application and click **Add New Flow** to start building a new workflow.

    <Frame>
      <img alt="Langflow main interface with add new flow button" />
    </Frame>
  </Step>

  <Step title="Select Blank Flow">
    Choose **Blank Flow** to start with a clean workspace where you can build your custom workflow.

    <Frame>
      <img alt="Langflow template selection showing blank flow option" />
    </Frame>
  </Step>

  <Step title="Search for MCP Tools">
    In the component search bar, type "MCP tools" to find the Model Context Protocol integration component.

    <Frame>
      <img alt="Searching for MCP tools in Langflow component library" />
    </Frame>

    <Check>
      The MCP Tools component enables Langflow to connect with external MCP servers like Membit, providing real-time context to your workflows.
    </Check>
  </Step>

  <Step title="Configure MCP Server">
    Configure the MCP Tools component by adding a new MCP server:

    1. Click **Add MCP Server**
    2. Select **STDIO** as the connection type

    <Frame>
      <img alt="MCP server configuration interface showing STDIO option" />
    </Frame>

    **STDIO Configuration:**

    * **Name**: `membit-mcp`
    * **Command**: `npx -y mcp-remote https://mcp.membit.ai/mcp`
    * **Argument 1**: `--header`
    * **Argument 2**: `X-Membit-Api-Key:${MEMBIT_API_KEY}`
    * **Environment Variables**: `MEMBIT_API_KEY <your-api-key>`

    <Warning>
      Replace `<your-api-key>` with your actual Membit API key. Keep this credential secure and don't share it with unauthorized users.
    </Warning>

    3. Click **Add Server** to save the configuration
    4. Click **Toggle Tool Mode** to enable the MCP tools

    <Frame>
      <img alt="MCP tools configuration showing toggle tool mode option" />
    </Frame>
  </Step>
</Steps>

## Building Your First Workflow

Now let's create a complete workflow that uses Membit's real-time context:

<Steps>
  <Step title="Add Agent Component">
    Search for "agent" in the component library and click **Add** to add an Agent component to your workflow.

    <Frame>
      <img alt="Agent component in Langflow component library" />
    </Frame>

    <Check>
      The Agent component acts as the orchestrator, managing how your workflow processes requests and coordinates responses.
    </Check>
  </Step>

  <Step title="Configure Agent Model">
    Configure the Agent component with your preferred language model:

    <Frame>
      <img alt="Config agent component" />
    </Frame>

    * **Model Provider**: Select "Gemini 2.5 Flash" (or your preferred model)
    * **API Key**: Set your Google AI Studio API key

    <Tip>
      You can use other model providers like OpenAI, Anthropic, or local models depending on your preference and requirements.
    </Tip>
  </Step>

  <Step title="Connect MCP Tools">
    Connect the **Membit MCP** component to the **Agent Tools** input to provide real-time context capabilities.

    <Check>
      This connection enables your agent to access Membit's real-time social media context when processing user queries.
    </Check>
  </Step>

  <Step title="Add Chat Components">
    Add Chat Input and Chat Output components to create an interactive interface:

    1. **Chat Input** - To receive user messages
    2. **Chat Output** - To display agent responses

    <Frame>
      <img alt="Chat components in Langflow showing input and output nodes" />
    </Frame>

    **Connection Pattern:**

    * **Chat Input** → **Agent Input**
    * **Agent Response** → **Chat Output**

    <Frame>
      <img alt="Complete Langflow workflow showing connected components" />
    </Frame>
  </Step>

  <Step title="Test Your Workflow">
    Click **Playground** to test your workflow with real-time context from Membit.

    <Frame>
      <img alt="Langflow playground interface for testing workflows" />
    </Frame>

    Try asking questions like:

    * "Tell me about crypto trends"
    * "What's happening in AI today?"
    * "Give me the latest tech news"

    <Frame>
      <img alt="Langflow chat interface showing conversation with real-time context" />
    </Frame>

    <Check>
      If successful, your agent will respond with current information about your query topic, powered by Membit's real-time data feed.
    </Check>
  </Step>
</Steps>

## Troubleshooting

<AccordionGroup>
  <Accordion title="MCP Server STDIO Connection Issues">
    **Problem**: Cannot establish STDIO connection to Membit MCP server

    **Solutions**:

    Verify `mcp-remote` is available: run `npx mcp-remote --version` in terminal

    Check the command format: `npx -y mcp-remote https://mcp.membit.ai/mcp`

    Ensure Node.js is properly installed and accessible to Langflow

    Verify environment variable `MEMBIT_API_KEY` is set correctly

    Try restarting Langflow after configuration changes
  </Accordion>

  <Accordion title="Tool Mode Not Working">
    **Problem**: MCP tools don't appear or aren't accessible

    **Solutions**:

    Ensure "Toggle Tool Mode" is enabled after server configuration

    Verify the MCP server status shows as "Connected"

    Check server logs for connection errors or authentication failures

    Try removing and re-adding the MCP server configuration

    Confirm all arguments are in correct order: `--header` then `X-Membit-Api-Key:${MEMBIT_API_KEY}`
  </Accordion>

  <Accordion title="Agent Not Using Tools">
    **Problem**: Agent doesn't utilize Membit tools in responses

    **Solutions**:

    Ensure MCP Tools component is properly connected to Agent Tools input

    Try more explicit prompts: "Use the available tools to search for..."

    Verify the chat model supports tool/function calling (Gemini 2.5 Flash recommended)

    Check if the agent has proper system instructions about tool usage

    Test with simpler, more direct questions about current events
  </Accordion>

  <Accordion title="Workflow Component Connection Errors">
    **Problem**: Components won't connect or show connection errors

    **Solutions**:

    Verify component types match: Agent expects Tools input, not generic components

    Check that all required inputs are connected (Chat Input → Agent, Model → Agent)

    Ensure MCP Tools output is properly mapped to Agent Tools input

    Try reconnecting components in the correct order

    Restart the workflow and test connections step by step
  </Accordion>
</AccordionGroup>


# n8n
Source: https://docs.membit.ai/integrations/no-code-agent-frameworks/n8n

Integrate real-time context to your n8n AI workflows via Membit MCP.

<img alt="Cover Image" />

n8n is a powerful workflow automation tool that allows you to connect different services and build sophisticated automation. By integrating Membit with n8n, you can enhance your AI agents with real-time social context, enabling them to provide up-to-date insights about trending topics, news, and conversations happening across the web.

## Prerequisites

Before you begin, make sure you have:

* An active n8n instance (cloud or self-hosted)
* A Membit account with an API key [get your API key](/access-and-auth)
* Basic familiarity with n8n workflows and AI agents

## Setting Up Membit MCP Client

Follow these steps to integrate Membit with your n8n workflows:

<Steps>
  <Step title="Open the Node Panel">
    In your n8n workflow editor, open the node panel to add a new node to your workflow.

    <Frame>
      <img alt="n8n node panel interface showing available nodes" />
    </Frame>
  </Step>

  <Step title="Search for MCP Client">
    In the node search bar, type "MCP client" to find the Model Context Protocol client tool.

    <Frame>
      <img alt="Searching for MCP client in n8n node panel" />
    </Frame>

    <Check>
      The MCP Client Tool should appear in the search results. This tool enables n8n to communicate with external MCP servers like Membit.
    </Check>
  </Step>

  <Step title="Configure Membit MCP Client">
    Add the MCP Client Tool to your workflow and configure it with the following settings:

    ```
    Endpoint: https://mcp.membit.ai/mcp
    Server Transport: HTTP Streamable
    Authentication: Header Auth
      - Name: X-Membit-Api-Key
      - Value: <your-api-key>
    Tools to Include: All
    ```

    <Warning>
      Replace `<your-api-key>` with your actual Membit API key.
    </Warning>
  </Step>
</Steps>

## Building Your First Workflow

Now that your Membit MCP client is configured, let's create a complete workflow that uses real-time context:

<Steps>
  <Step title="Add Required Nodes">
    Create a complete workflow by adding and connecting the following nodes:

    1. **Chat Trigger** - To receive user input
    2. **AI Agent** - To process requests and coordinate responses
    3. **Google Gemini Chat Model** - For natural language processing
    4. **Membit MCP Client** - For real-time context
  </Step>

  <Step title="Connect the Nodes">
    Connect them in this order:

    * Chat Trigger → AI Agent
    * Google Gemini Chat Model → AI Agent
    * Membit MCP Client → AI Agent

    <Frame>
      <img alt="Complete n8n workflow showing connected nodes for Membit integration" />
    </Frame>

    <Check>
      The visual connections show the data flow - the AI Agent receives input from the Chat Trigger, uses the Gemini model for processing, and accesses Membit for real-time context.
    </Check>
  </Step>

  <Step title="Test Your Workflow">
    Use the chat interface to send a test message like:

    ```
    "Tell me about crypto news"
    ```

    or

    ```
    "What's trending in AI today?"
    ```

    Your AI agent should now respond with current, contextual information pulled from Membit's real-time data feed.

    <Frame>
      <img alt="n8n workflow execution result showing AI response with real-time context" />
    </Frame>

    <Check>
      If successful, you'll see responses that include recent trends, discussions, and insights that wouldn't be available in static training data.
    </Check>
  </Step>
</Steps>

## Troubleshooting

<AccordionGroup>
  <Accordion title="MCP Client Connection Issues">
    **Problem**: Cannot connect to Membit MCP server in n8n

    **Solutions**:

    Verify the endpoint URL is correct: `https://mcp.membit.ai/mcp`

    Ensure "Server Transport" is set to "HTTP Streamable"

    Check that "Authentication" is set to "Header Auth"

    Verify header name is exactly `X-Membit-Api-Key` (case-sensitive)

    Test the connection with a simple request first
  </Accordion>

  <Accordion title="Authentication Header Configuration">
    **Problem**: API key authentication is failing

    **Solutions**:

    Confirm the header name is `X-Membit-Api-Key` (not `Authorization`)

    Ensure there are no extra spaces or characters in the API key value

    Verify your Membit API key is active and valid

    Check that the header value contains only the API key (no "Bearer " prefix)

    Try regenerating your API key if authentication continues to fail
  </Accordion>

  <Accordion title="AI Agent Tool Integration">
    **Problem**: AI Agent doesn't use MCP Client tools

    **Solutions**:

    Ensure MCP Client is properly connected to the AI Agent node

    Verify "Tools to Include" is set to "All" in MCP Client configuration

    Check that the AI model (Google Gemini) supports function calling

    Make prompts more explicit: "Use available tools to search for current information about..."

    Test the MCP Client connection independently before connecting to AI Agent
  </Accordion>

  <Accordion title="Workflow Node Connection Errors">
    **Problem**: Nodes won't connect or show connection issues

    **Solutions**:

    Verify the connection order: Chat Trigger → AI Agent, MCP Client → AI Agent

    Ensure all required node inputs are satisfied

    Check that node versions are compatible with each other

    Try disconnecting and reconnecting nodes in the correct sequence

    Restart the n8n workflow editor if connections appear broken
  </Accordion>

  <Accordion title="Chat Trigger Not Responding">
    **Problem**: Chat interface doesn't respond or process messages

    **Solutions**:

    Verify the Chat Trigger node is properly configured and activated

    Ensure the workflow is saved and deployed

    Check that all nodes in the workflow are properly connected

    Test with simple messages first to verify basic functionality

    Review workflow execution logs for error messages
  </Accordion>
</AccordionGroup>


# AutoGen
Source: https://docs.membit.ai/integrations/python-agent-framework/autogen

Integrate real-time context to your AutoGen AI agents via Membit MCP.

<img alt="Cover Image" />

Enhance your AutoGen applications with real-time social media context from Membit. This integration allows your AI agents to access up-to-the-minute discussions, trends, and insights from platforms like X (Twitter), Farcaster, and more.

## Prerequisites

Before you begin, ensure you have:

* Python 3.10 or higher installed
* A Membit account with API access
* Basic familiarity with AutoGen agents
* Node.js installed (for MCP remote client)

<Warning>
  You'll need valid Membit API credentials and the MCP remote URL. If you don't
  have access yet, [get your API key](/access-and-auth) to get started.
</Warning>

## Installation

Install the required packages for AutoGen and MCP integration:

```bash theme={null}
# Install AutoGen with MCP tools
pip install autogenstudio

# Install MCP remote client (requires Node.js)
npm install -g mcp-remote
```

<Tip>
  We recommend using a virtual environment to manage your Python dependencies
  and avoid conflicts.
</Tip>

## Quick Start

<Steps>
  <Step title="Import required modules">
    Import the necessary components for AutoGen and MCP integration:

    ```python theme={null}
    import asyncio

    from autogen_agentchat.agents import AssistantAgent
    from autogen_agentchat.ui import Console
    from autogen_ext.models.openai import OpenAIChatCompletionClient
    from autogen_ext.tools.mcp import McpWorkbench, StdioServerParams
    ```
  </Step>

  <Step title="Configure MCP server parameters">
    Set up the connection to Membit's MCP server:

    ```python theme={null}
    params = StdioServerParams(
        command="npx",
        args=[
            "mcp-remote",
            "https://mcp.membit.ai/mcp",
            "--header",
            "X-Membit-Api-Key:${MEMBIT_API_KEY}",
        ],
        env={
            "MEMBIT_API_KEY": <your-api-key>,
        },
        read_timeout_seconds=60,
    )
    ```

    <Note>
      Make sure you have `mcp-remote` installed globally via npm for this to work.
    </Note>

    <Warning>
      Replace `<your-api-key>` with your actual Membit API key. Keep this credential secure and don't share it with unauthorized users.
    </Warning>
  </Step>

  <Step title="Initialize your model client">
    Set up your language model client:

    ```python theme={null}
    model_client = OpenAIChatCompletionClient(model="gpt-4o-mini")
    ```
  </Step>

  <Step title="Create your Membit-powered agent">
    Use McpWorkbench to connect Membit tools to your AutoGen agent:

    ```python theme={null}
    async with McpWorkbench(server_params=params) as workbench:
        # List available tools
        tools = await workbench.list_tools()

        # Create assistant agent with Membit tools
        agent = AssistantAgent(
            "membit_assistant",
            model_client=model_client,
            workbench=workbench,
            reflect_on_tool_use=True,
            model_client_stream=True,
            system_message="You are a social media analyst with access to real-time data. Use Membit tools to analyze trending discussions and provide insights.",
        )
    ```
  </Step>

  <Step title="Run your agent">
    Execute your agent with a social media analysis task:

    ```python theme={null}
    await Console(
        agent.run_stream(
            task="What are the most trending discussions about AI today? Use cluster_search to find hot topics and provide insights with URLs."
        )
    )
    ```

    <Check>
      Your AutoGen agent is now powered by real-time social media context from Membit!
    </Check>
  </Step>
</Steps>

## Complete Example

Here's a full working example that demonstrates the integration:

```python theme={null}
import asyncio

from autogen_agentchat.agents import AssistantAgent
from autogen_agentchat.ui import Console
from autogen_ext.models.openai import OpenAIChatCompletionClient
from autogen_ext.tools.mcp import McpWorkbench, StdioServerParams

async def main() -> None:
    # Configure MCP server connection
    params = StdioServerParams(
        command="npx",
        args=[
            "mcp-remote",
            "https://mcp.membit.ai/mcp",
            "--header",
            "X-Membit-Api-Key:${MEMBIT_API_KEY}",
        ],
        env={
            # Replace `<your-api-key>` with your actual Membit API key.
            "MEMBIT_API_KEY": <your-api-key>,
        },
        read_timeout_seconds=60,
    )

    # Initialize model client
    model_client = OpenAIChatCompletionClient(model="gpt-4o-mini")

    # Create and run agent with Membit tools
    async with McpWorkbench(server_params=params) as workbench:
        tools = await workbench.list_tools()
        print("Available Membit Tools:")
        for tool in tools:
            print(f"- {tool.name}: {tool.description}")

        agent = AssistantAgent(
            "membit_assistant",
            model_client=model_client,
            workbench=workbench,
            reflect_on_tool_use=True,
            model_client_stream=True,
            system_message="You are a helpful social media analyst. Use cluster_search to find trending topics, cluster_info for detailed analysis, and post_search for specific posts.",
        )

        await Console(
            agent.run_stream(
                task="What are the most trending discussions today related to Bitcoin? Use cluster_search to find hot topics and provide the best conversations to follow with URLs."
            )
        )

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

## Troubleshooting

<AccordionGroup>
  <Accordion title="MCP Connection Issues">
    **Problem**: Cannot connect to Membit MCP server

    **Solutions**:

    * Verify `mcp-remote` is installed: `npm list -g mcp-remote`
    * Check your API key is correct
    * Ensure Node.js is properly installed and accessible
    * Increase `read_timeout_seconds` if experiencing timeouts
  </Accordion>

  <Accordion title="Workbench Tool Loading">
    **Problem**: McpWorkbench fails to load tools

    **Solutions**:

    * Verify MCP server parameters are correct
    * Check network connectivity and firewall settings
    * Ensure your Membit API credentials are valid
    * Try listing tools first to verify connection: `await workbench.list_tools()`
  </Accordion>

  <Accordion title="Agent Tool Usage Issues">
    **Problem**: Agents don't use Membit tools effectively

    **Solutions**:

    * Make system messages more explicit about tool usage
    * Enable `reflect_on_tool_use=True` for better tool reasoning
    * Use `model_client_stream=True` for real-time feedback
    * Test with simpler, more direct task descriptions
  </Accordion>
</AccordionGroup>

```
```


# CrewAI
Source: https://docs.membit.ai/integrations/python-agent-framework/crewai

Integrate real-time context to your CrewAI agents via Membit MCP.

<img alt="Cover Image" />

Enhance your CrewAI applications with real-time social media context from Membit. This integration allows your AI agents to access up-to-the-minute discussions, trends, and insights from platforms like X (Twitter), Farcaster, and more.

## Prerequisites

Before you begin, ensure you have:

* Python 3.10 or higher installed
* A Membit account with API access
* Basic familiarity with CrewAI agents and crews
* Node.js installed (for MCP remote client)

<Warning>
  You'll need valid Membit API credentials and the MCP remote URL. If you don't
  have access yet, [get your API key](/access-and-auth) to get started.
</Warning>

## Installation

Install the required packages for CrewAI and MCP integration:

```bash theme={null}
# Install CrewAI tools
pip install 'crewai-tools[mcp]'

# Install MCP remote client (requires Node.js)
npm install -g mcp-remote
```

<Tip>
  We recommend using a virtual environment to manage your Python dependencies
  and avoid conflicts.
</Tip>

## Quick Start

<Steps>
  <Step title="Import required modules">
    Import the necessary components for CrewAI and MCP integration:

    ```python theme={null}
    from crewai import Agent, Task, Crew
    from crewai_tools import MCPServerAdapter
    from mcp import StdioServerParameters
    ```
  </Step>

  <Step title="Configure MCP server parameters">
    Set up the connection to Membit's MCP server:

    ```python theme={null}
    server_params = StdioServerParameters(
        command="npx",
        args=[
            "mcp-remote",
            "https://mcp.membit.ai/mcp",
            "--header",
            "X-Membit-Api-Key:${MEMBIT_API_KEY}",
        ],
        env={
            "MEMBIT_API_KEY": <your-api-key>,
        },
    )
    ```

    <Note>
      Make sure you have `mcp-remote` installed globally via npm for this to work.
    </Note>

    <Warning>
      Replace `<your-api-key>` with your actual Membit API key. Keep this credential secure and don't share it with unauthorized users.
    </Warning>
  </Step>

  <Step title="Create your Membit-powered agent">
    Use the MCPServerAdapter to connect Membit tools to your CrewAI agent:

    ```python theme={null}
    with MCPServerAdapter(server_params) as membit_tools:
        # Create an agent with Membit tools
        analyst_agent = Agent(
            role="Social Media Data Analyst",
            goal="Analyze trending social media data and provide insights using Membit tools",
            backstory="You are an experienced social media analyst with expertise in identifying trends and understanding online conversations.",
            allow_code_execution=False,
            tools=membit_tools,
        )
    ```
  </Step>

  <Step title="Define your analysis task">
    Create a task that leverages Membit's real-time data:

    ```python theme={null}
    analysis_task = Task(
        description="Find the most trending discussions today about AI technology. Use cluster_search to identify hot topics and provide insights with source URLs.",
        agent=analyst_agent,
        expected_output="A comprehensive analysis of trending AI discussions with key insights and source URLs",
    )
    ```
  </Step>

  <Step title="Execute your crew">
    Create and run your CrewAI crew:

    ```python theme={null}
    # Create and execute the crew
    crew = Crew(
        agents=[analyst_agent],
        tasks=[analysis_task]
    )

    result = crew.kickoff()
    print(result)
    ```

    <Check>
      Your CrewAI agent is now powered by real-time social media context from Membit!
    </Check>
  </Step>
</Steps>

## Complete Example

Here's a full working example that demonstrates the integration:

```python theme={null}
from crewai import Agent, Task, Crew
from crewai_tools import MCPServerAdapter
from mcp import StdioServerParameters

def main():
    server_params = StdioServerParameters(
        command="npx",
        args=[
            "mcp-remote",
            "https://mcp.membit.ai/mcp",
            "--header",
            "X-Membit-Api-Key:${MEMBIT_API_KEY}",
        ],
        env={
            # Replace `<your-api-key>` with your actual Membit API key.
            "MEMBIT_API_KEY": <your-api-key>,
        },
    )

    with MCPServerAdapter(server_params) as membit_tools:
        # Create a social media analyst agent
        analyst_agent = Agent(
            role="Social Media Data Analyst",
            goal="Analyze trending social media data and provide actionable insights",
            backstory="You are an expert social media analyst who specializes in identifying trends, analyzing sentiment, and understanding online conversations across platforms.",
            allow_code_execution=False,
            tools=membit_tools,
        )

        # Create analysis task
        analysis_task = Task(
            description="What are the most trending discussions today related to Bitcoin? Use cluster_search to find hot topics and provide the best conversations to follow with URLs.",
            agent=analyst_agent,
            expected_output="A detailed analysis of trending Bitcoin discussions with source URLs and key insights",
        )

        # Execute the crew
        crew = Crew(agents=[analyst_agent], tasks=[analysis_task])
        result = crew.kickoff()

        print("Analysis Results:")
        print(result)

if __name__ == "__main__":
    main()
```

## Troubleshooting

<AccordionGroup>
  <Accordion title="MCP Connection Issues">
    **Problem**: Cannot connect to Membit MCP server

    **Solutions**:

    * Verify `mcp-remote` is installed: `npm list -g mcp-remote`
    * Check your API key
    * Ensure Node.js is properly installed and accessible
    * Test connectivity with `npx mcp-remote` directly
  </Accordion>

  <Accordion title="Tool Loading Failures">
    **Problem**: MCPServerAdapter fails to load tools

    **Solutions**:

    * Ensure the MCP server parameters are correct
    * Check network connectivity and firewall settings
    * Verify your Membit API credentials are valid
    * Try running the MCP server manually to test connection
  </Accordion>

  <Accordion title="Agent Execution Issues">
    **Problem**: Agents fail to use Membit tools effectively

    **Solutions**:

    * Be explicit in task descriptions about which tools to use
    * Set `allow_code_execution=False` unless specifically needed
    * Use verbose mode to see tool usage during execution
    * Ensure agents have clear, specific roles and goals
  </Accordion>
</AccordionGroup>


# LangChain
Source: https://docs.membit.ai/integrations/python-agent-framework/langchain

Integrate real-time context to your LangChain AI agents via Membit MCP..

<img alt="Cover Image" />

Enhance your LangChain applications with real-time social media context from Membit. This integration allows your AI agents to access up-to-the-minute discussions, trends, and insights from platforms like X (Twitter), Farcaster, and more.

## Prerequisites

Before you begin, ensure you have:

* Python 3.10 or higher installed
* A Membit account with API access
* Basic familiarity with LangChain agents
* Node.js installed (for MCP remote client)

<Warning>
  You'll need valid Membit API credentials and the MCP remote URL. If you don't
  have access yet, [get your API key](/access-and-auth) to get started.
</Warning>

## Installation

Install the required packages for LangChain and MCP integration:

```bash theme={null}
# Install LangChain MCP adapter
pip install langchain-mcp-adapters

# Install MCP remote client (requires Node.js)
npm install -g mcp-remote
```

<Tip>
  We recommend using a virtual environment to manage your Python dependencies
  and avoid conflicts.
</Tip>

## Quick Start

<Steps>
  <Step title="Import required modules">
    Import the necessary components for LangChain and MCP integration:

    ```python theme={null}
    import asyncio

    from mcp import ClientSession, StdioServerParameters
    from mcp.client.stdio import stdio_client
    from langchain.agents import create_openai_tools_agent, AgentExecutor
    from langchain.chat_models import init_chat_model
    from langchain_core.prompts import ChatPromptTemplate, MessagesPlaceholder
    from langchain.schema import HumanMessage
    from langchain_mcp_adapters.tools import load_mcp_tools
    ```
  </Step>

  <Step title="Configure your LLM">
    Set up your language model with the provider of your choice:

    ```python theme={null}
    llm = init_chat_model(
        model="gpt-4o",
        model_provider="openai",
    )
    ```
  </Step>

  <Step title="Configure MCP server parameters">
    Set up the connection to Membit's MCP server:

    ```python theme={null}
    server_params = StdioServerParameters(
        command="npx",
        args=[
            "mcp-remote",
            "https://mcp.membit.ai/mcp",
            "--header",
            "X-Membit-Api-Key:${MEMBIT_API_KEY}",
        ],
        env={
            "MEMBIT_API_KEY": <your-api-key>,
        },
    )
    ```

    <Note>
      Make sure you have `mcp-remote` installed globally via npm for this to work.
    </Note>

    <Warning>
      Replace `<your-api-key>` with your actual Membit API key. Keep this credential secure and don't share it with unauthorized users.
    </Warning>
  </Step>

  <Step title="Create agent prompt">
    Define a prompt template that encourages the agent to use Membit tools:

    ```python theme={null}
    prompt = ChatPromptTemplate.from_messages(
        [
            (
                "system",
                "Make sure you utilize membit tools to get the most trending data."
            ),
            MessagesPlaceholder(variable_name="messages"),
            MessagesPlaceholder(variable_name="agent_scratchpad"),
        ]
    )
    ```
  </Step>

  <Step title="Create and run your agent">
    Connect to Membit and create your LangChain agent:

    ```python theme={null}
    async def main():
        async with stdio_client(server_params) as (read, write):
            async with ClientSession(read, write) as session:
                # Initialize the MCP connection
                await session.initialize()

                # Load Membit tools from MCP session
                mcp_tools = await load_mcp_tools(session)

                # Create the LangChain agent
                agent = create_openai_tools_agent(
                    llm=llm,
                    tools=mcp_tools,
                    prompt=prompt
                )

                # Create executor
                agent_executor = AgentExecutor(
                    agent=agent,
                    tools=mcp_tools,
                    verbose=True
                )

                # Query your agent
                await agent_executor.ainvoke({
                    "messages": [HumanMessage(content=
                        "What are the most trending discussions about AI today?"
                    )]
                })

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

    <Check>
      Your LangChain agent is now powered by real-time social media context from Membit!
    </Check>
  </Step>
</Steps>

## Complete Example

Here's a full working example with enhanced functionality:

```python theme={null}
import asyncio

from langchain.agents import AgentExecutor, create_openai_tools_agent
from langchain.chat_models import init_chat_model
from langchain.schema import HumanMessage
from langchain_core.prompts import ChatPromptTemplate, MessagesPlaceholder
from langchain_mcp_adapters.tools import load_mcp_tools
from mcp import ClientSession, StdioServerParameters
from mcp.client.stdio import stdio_client

# Initialize LLM
llm = init_chat_model(
    model="gpt-4o",
    model_provider="openai",
)

server_params = StdioServerParameters(
    command="npx",
    args=[
        "mcp-remote",
        "https://mcp.membit.ai/mcp",
        "--header",
        "X-Membit-Api-Key:${MEMBIT_API_KEY}",
    ],
    env={
        # Replace `<your-api-key>` with your actual Membit API key.
        "MEMBIT_API_KEY": <your-api-key>,
    },
)

prompt = ChatPromptTemplate.from_messages([
    (
        "system",
        "You are a social media analyst with access to real-time data. "
        "Make sure you utilize membit tools to get the most trending data."
    ),
    MessagesPlaceholder(variable_name="messages"),
    MessagesPlaceholder(variable_name="agent_scratchpad"),
])

async def main():
    async with stdio_client(server_params) as (read, write):
        async with ClientSession(read, write) as session:
            await session.initialize()

            mcp_tools = await load_mcp_tools(session)

            agent = create_openai_tools_agent(
                llm=llm,
                tools=mcp_tools,
                prompt=prompt
            )

            agent_executor = AgentExecutor(
                agent=agent,
                tools=mcp_tools,
                verbose=True
            )

            user_input = (
                "What are the most trending discussions today related to Bitcoin? "
                "Give me the best conversations to follow with URLs."
            )

            await agent_executor.ainvoke({
                "messages": [HumanMessage(content=user_input)]
            })

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

## Troubleshooting

<AccordionGroup>
  <Accordion title="MCP Connection Issues">
    **Problem**: Cannot connect to Membit MCP server

    **Solutions**:

    * Verify `mcp-remote` is installed: `npm list -g mcp-remote`
    * Check your API key
    * Ensure Node.js is properly installed and accessible
    * Try running `npx mcp-remote` directly to test connectivity
  </Accordion>

  <Accordion title="Tool Loading Failures">
    **Problem**: `load_mcp_tools` returns empty or fails

    **Solutions**:

    * Initialize the MCP session before loading tools
    * Check network connectivity and firewall settings
    * Verify your Membit API credentials are valid
    * Look for error messages in the MCP connection logs
  </Accordion>

  <Accordion title="Agent Execution Errors">
    **Problem**: Agent fails to execute or use tools properly

    **Solutions**:

    * Check that tools are properly passed to both agent and executor
    * Ensure your prompt includes the required message placeholders
    * Verify the LLM has sufficient context window for tool responses
    * Test with simpler queries first
  </Accordion>
</AccordionGroup>


# LlamaIndex
Source: https://docs.membit.ai/integrations/python-agent-framework/llamaindex

Integrate real-time context to your LlamaIndex AI agents via Membit MCP.

<img alt="Cover Image" />

Enhance your LlamaIndex applications with real-time social media context from Membit. This integration allows your AI agents to access up-to-the-minute discussions, trends, and insights from platforms like X (Twitter), Farcaster, and more.

## Prerequisites

Before you begin, ensure you have:

* Python 3.10 or higher installed
* A Membit account with API access
* Basic familiarity with LlamaIndex agents

<Warning>
  You'll need valid Membit API credentials. If you don't have access yet, [get
  your API key](/access-and-auth) to get started.
</Warning>

## Installation

Install the required LlamaIndex MCP tools package:

```bash theme={null}
pip install llama-index-tools-mcp
```

<Tip>
  We recommend using a virtual environment to manage your dependencies and avoid
  conflicts.
</Tip>

## Quick Start

<Steps>
  <Step title="Import the required modules">
    First, import the necessary components from LlamaIndex:

    ```python theme={null}
    from llama_index.tools.mcp import (
        BasicMCPClient,
        get_tools_from_mcp_url,
        aget_tools_from_mcp_url,
    )
    from llama_index.core.agent import ReActAgent
    from llama_index.core.memory import ChatMemoryBuffer
    from llama_index.llms.openai import OpenAI
    ```
  </Step>

  <Step title="Get Membit tools from MCP server">
    Connect to Membit's MCP server to retrieve available tools:

    <Tabs>
      <Tab title="Async">
        ```python theme={null}
        # Create MCP Client
        mcp_client = BasicMCPClient(
            command_or_url="npx",
            args=[
                "mcp-remote",
                "https://mcp.membit.ai/mcp",
                "--header",
                "X-Membit-Api-Key:${MEMBIT_API_KEY}",
            ],
            env={
                "MEMBIT_API_KEY": <your-api-key>,
            },
        )
        # Async method
        tools = await aget_tools_from_mcp_url(
            "",
            client=mcp_client,
        )
        ```
      </Tab>

      <Tab title="Sync">
        ```python theme={null}
        # Create MCP Client
        mcp_client = BasicMCPClient(
            command_or_url="npx",
            args=[
                "mcp-remote",
                "https://mcp.membit.ai/mcp",
                "--header",
                "X-Membit-Api-Key:${MEMBIT_API_KEY}",
            ],
            env={
                "MEMBIT_API_KEY": <your-api-key>,
            },
        )
        # Synchronous method
        tools = get_tools_from_mcp_url(
            "",
            client=mcp_client,
        )
        ```
      </Tab>
    </Tabs>

    <Warning>
      Replace `<your-api-key>` with your actual Membit API key. Keep this credential secure and don't share it with unauthorized users.
    </Warning>
  </Step>

  <Step title="Create and configure your agent">
    Set up a LlamaIndex ReAct agent with Membit tools:

    ```python theme={null}
    # Initialize your LLM
    llm = OpenAI(model="gpt-4o-mini")

    # Create the agent with Membit tools
    agent = ReActAgent(
        tools=tools,
        llm=llm,
        memory=ChatMemoryBuffer.from_defaults(),
        verbose=True,
    )
    ```

    <Check>
      Your agent is now ready to access real-time social media context through Membit!
    </Check>
  </Step>

  <Step title="Query your agent">
    Start asking questions that leverage real-time social data:

    ```python theme={null}
    response = agent.query(
        "Use cluster_search to find trending Bitcoin discussions today, "
        "then use cluster_info to get details about the most interesting cluster."
    )

    print(response)
    ```
  </Step>
</Steps>

## Complete Example

Here's a full working example that demonstrates the integration:

```python theme={null}
import asyncio

from llama_index.core.agent import ReActAgent
from llama_index.core.memory import ChatMemoryBuffer
from llama_index.llms.openai import OpenAI
from llama_index.tools.mcp import BasicMCPClient, aget_tools_from_mcp_url

async def main():
    # Create MCP client
    mcp_client = BasicMCPClient(
        command_or_url="npx",
        args=[
            "mcp-remote",
            "https://mcp.membit.ai/mcp",
            "--header",
            "X-Membit-Api-Key:${MEMBIT_API_KEY}",
        ],
        env={
            # Replace `<your-api-key>` with your actual Membit API key.
            "MEMBIT_API_KEY": <your-api-key>,
        },
    )

    # Get Membit tools
    tools = await aget_tools_from_mcp_url(
        "",
        client=mcp_client,
    )

    # Initialize LLM
    llm = OpenAI(model="gpt-4o-mini")

    # Create agent
    agent = ReActAgent(
        tools=tools,
        llm=llm,
        memory=ChatMemoryBuffer.from_defaults(),
        verbose=True,
    )

    # Query for trending crypto discussions
    response = await agent.aquery(
        "What are the most trending discussions about Bitcoin today? "
        "Use cluster_search to find the hottest topics and give me insights."
    )

    print(response)

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

## Troubleshooting

<AccordionGroup>
  <Accordion title="Connection Issues">
    **Problem**: Cannot connect to Membit MCP server

    **Solutions**:

    * Verify your Membit MCP URL is correct
    * Check your network connection and firewall settings
    * Ensure your API credentials are valid and not expired
    * Try the synchronous method if async isn't working
  </Accordion>

  <Accordion title="No Results Returned">
    **Problem**: Queries return empty or limited results

    **Solutions**:

    * Make your search terms more general or use synonyms
    * Check if the topic is currently being discussed on social media
    * Verify your search timeframe isn't too restrictive
    * Try different query phrasings
  </Accordion>

  <Accordion title="Performance Issues">
    **Problem**: Slow response times or timeouts

    **Solutions**:

    * Use async methods for better performance
    * Implement caching for frequently requested data
    * Optimize your query complexity
    * Check your internet connection stability
  </Accordion>
</AccordionGroup>


# Mastra
Source: https://docs.membit.ai/integrations/typescript-agent-framework/mastra

Integrate real-time context to your Mastra AI agents via Membit MCP.

<img alt="Cover Image" />

Enhance your Mastra applications with real-time social media context from Membit. This integration allows your AI agents to access up-to-the-minute discussions, trends, and insights from platforms like X (Twitter), Farcaster, and more.

## Prerequisites

Before you begin, ensure you have:

* Node.js 20 or higher installed
* A Membit account with API access
* Basic familiarity with Mastra agents
* TypeScript knowledge (recommended)

<Warning>
  You'll need valid Membit API credentials and the MCP remote URL. If you don't
  have access yet, [get your API key](/access-and-auth) to get started.
</Warning>

## Installation

Install the required packages for Mastra and MCP integration:

```bash theme={null}
# Install Mastra with MCP support
npm install @mastra/mcp@latest

# Install MCP remote client
npm install -g mcp-remote
```

<Tip>
  Mastra works best with TypeScript. Make sure your project is configured for
  TypeScript development.
</Tip>

## Quick Start

<Steps>
  <Step title="Import required modules">
    Import the necessary components for Mastra and MCP integration:

    ```typescript theme={null}
    import { openai } from "@ai-sdk/openai";
    import { Agent } from "@mastra/core/agent";
    import { LibSQLStore } from "@mastra/libsql";
    import { MCPClient } from "@mastra/mcp";
    ```
  </Step>

  <Step title="Initialize MCP client">
    Create an MCP client to connect to Membit's tools:

    ```typescript theme={null}
    export const mcp = new MCPClient({
      servers: {
        membit: {
          command: "npx",
          env: {
            MEMBIT_API_KEY: <your-api-key>,
          },
          args: [
            "mcp-remote",
            "https://mcp.membit.ai/mcp",
            "--header",
            "X-Membit-Api-Key:${MEMBIT_API_KEY}",
          ],
        },
      },
    });
    ```

    <Note>
      Make sure you have `mcp-remote` installed globally via npm for this to work.
    </Note>

    <Warning>
      Replace `<your-api-key>` with your actual Membit API key. Keep this credential secure and don't share it with unauthorized users.
    </Warning>
  </Step>

  <Step title="Create your Membit-powered agent">
    Create a Mastra agent with Membit tools and memory:

    ```typescript theme={null}
    export const membitAgent = new Agent({
      name: "Social Media Analyst",
      instructions: `You are a social media analyst with access to real-time data. Use cluster_search to find trending discussions, cluster_info for detailed analysis, and post_search for specific posts.`,
      model: openai("gpt-4o-mini"),
      tools: await mcp.getTools(),
    });
    ```
  </Step>

  <Step title="Use your agent">
    Execute your agent with social media analysis tasks:

    ```typescript theme={null}
    const result = await membitAgent.generate(
      "What are the most trending discussions about AI today? Use cluster_search to find hot topics and provide insights with URLs."
    );

    console.log(result.text);
    ```

    <Check>
      Your Mastra agent is now powered by real-time social media context from Membit!
    </Check>
  </Step>
</Steps>

## Complete Example

Here's a full working example that demonstrates the integration:

```typescript theme={null}
import { openai } from "@ai-sdk/openai";
import { Agent } from '@mastra/core/agent';
import { LibSQLStore } from '@mastra/libsql';
import { MCPClient } from "@mastra/mcp";

// Initialize MCP client for Membit
export const mcp = new MCPClient({
  servers: {
    membit: {
      command: "npx",
      env: {
      // Replace `<your-api-key>` with your actual Membit API key.
        MEMBIT_API_KEY: <your-api-key>,
      },
      args: [
        "mcp-remote",
        "https://mcp.membit.ai/mcp",
        "--header",
        "X-Membit-Api-Key:${MEMBIT_API_KEY}",
      ],
    },
  },
});

// Create Membit-powered agent
export const membitAgent = new Agent({
  name: 'Membit Social Analyst',
  instructions: `You are an expert social media analyst with access to real-time trending data.
Use cluster_search to find trending discussions, cluster_info to dive deeper into specific conversations,
and post_search to find individual posts. Always provide context and source URLs.`,
  model: openrouter("anthropic/claude-3-5-sonnet-20241022"),
  tools: await mcp.getTools(),
});

async function main() {
  try {
    const result = await membitAgent.generate(
      "What are the most trending discussions today related to Bitcoin? Use cluster_search to find hot topics and provide the best conversations to follow with URLs."
    );

    console.log("Analysis Results:");
    console.log(result.text);

  } catch (error) {
    console.error("Error during analysis:", error);
  }
}

main();
```

## Troubleshooting

<AccordionGroup>
  <Accordion title="MCP Connection Issues">
    **Problem**: Cannot connect to Membit MCP server

    **Solutions**:

    * Verify `mcp-remote` is installed: `npm list -g mcp-remote`
    * Check your API key
    * Ensure Node.js is properly installed and accessible
    * Test connectivity with `npx mcp-remote` directly
  </Accordion>

  <Accordion title="Tool Loading Failures">
    **Problem**: `mcp.getTools()` returns empty or fails

    **Solutions**:

    * Ensure MCP client is properly configured with correct server parameters
    * Check network connectivity and firewall settings
    * Verify your Membit API credentials are valid
    * Try initializing the MCP client in a try-catch block
  </Accordion>

  <Accordion title="Agent Generation Issues">
    **Problem**: Agents don't use Membit tools effectively

    **Solutions**:

    * Make agent instructions more explicit about tool usage
    * Test with simpler, more direct queries first
    * Check that tools are properly loaded: `console.log(await mcp.getTools())`
    * Verify the agent's memory storage is accessible
  </Accordion>
</AccordionGroup>

```
```


# VoltAgent
Source: https://docs.membit.ai/integrations/typescript-agent-framework/voltagent

Integrate real-time context to your VoltAgent AI agents via Membit MCP.

<img alt="Cover Image" />

Enhance your VoltAgent applications with real-time social media context from Membit. This integration allows your AI agents to access up-to-the-minute discussions, trends, and insights from platforms like X (Twitter), Farcaster, and more.

## Prerequisites

Before you begin, ensure you have:

* Node.js 20 or higher installed
* A Membit account with API access
* Basic familiarity with VoltAgent agents and workflows
* TypeScript knowledge (recommended)

<Warning>
  You'll need valid Membit API credentials and the MCP remote URL. If you don't
  have access yet, [get your API key](/access-and-auth) to get started.
</Warning>

## Installation

Install the required packages for VoltAgent and MCP integration:

```bash theme={null}
# Install VoltAgent core packages
npm install @voltagent/core
```

<Tip>
  VoltAgent works best with TypeScript and structured logging. Make sure your
  project is configured accordingly.
</Tip>

## Quick Start

<Steps>
  <Step title="Import required modules">
    Import the necessary components for VoltAgent and MCP integration:

    ```typescript theme={null}
    import { VoltAgent, Agent, MCPConfiguration } from "@voltagent/core";
    import { createPinoLogger } from "@voltagent/logger";
    import { VercelAIProvider } from "@voltagent/vercel-ai";
    import { openai } from "@ai-sdk/openai";
    ```
  </Step>

  <Step title="Configure MCP connection">
    Set up the MCP configuration to connect to Membit's tools:

    ```typescript theme={null}
    const mcpConfig = new MCPConfiguration({
      servers: {
        membit: {
          type: "stdio",
          command: "npx",
          env: {
            MEMBIT_API_KEY: <your-api-key>,
          },
          args: [
            "mcp-remote",
            "https://mcp.membit.ai/mcp",
            "--header",
            "X-Membit-Api-Key:${MEMBIT_API_KEY}",
          ],
        },
      },
    });
    ```

    <Note>
      VoltAgent supports streamable HTTP transport for efficient MCP connections.
    </Note>

    <Warning>
      Replace `<your-api-key>` with your actual Membit API key. Keep this credential secure and don't share it with unauthorized users.
    </Warning>
  </Step>

  <Step title="Create your Membit-powered agent">
    Create a VoltAgent agent with Membit tools:

    ```typescript theme={null}
    const membitAgent = new Agent({
      name: "social-media-analyst",
      instructions:
        "You are a social media analyst with access to real-time data. Use cluster_search to find trending discussions, cluster_info for detailed analysis, and post_search for specific posts.",
      llm: new VercelAIProvider(),
      model: openai("gpt-4o-mini"),
      tools: await mcpConfig.getTools(),
    });
    ```
  </Step>

  <Step title="Initialize VoltAgent system">
    Create the VoltAgent system with your agent:

    ```typescript theme={null}
    // Initialize VoltAgent with your agent(s)
    new VoltAgent({
      agents: {
        membitAgent,
      },
    });
    ```

    <Check>
      Your VoltAgent is now powered by real-time social media context from Membit!
    </Check>
  </Step>
</Steps>

## Complete Example

Here's a full working example that demonstrates the integration:

```typescript theme={null}
import { VoltAgent, Agent, MCPConfiguration } from "@voltagent/core";
import { createPinoLogger } from "@voltagent/logger";
import { VercelAIProvider } from "@voltagent/vercel-ai";
import { openai } from "@ai-sdk/openai";

// Configure MCP connection to Membit
const mcpConfig = new MCPConfiguration({
  servers: {
    membit: {
      type: "stdio",
      command: "npx",
      env: {
        MEMBIT_API_KEY: <your-api-key>,
      },
      args: [
        "mcp-remote",
        "https://mcp.membit.ai/mcp",
        "--header",
        "X-Membit-Api-Key:${MEMBIT_API_KEY}",
      ],
    },
  },
});

// Create Membit-powered agent
const socialAnalyst = new Agent({
  name: "membit-social-analyst",
  instructions: `You are an expert social media analyst with access to real-time trending data.
Use cluster_search to find trending discussions, cluster_info to dive deeper into specific conversations,
and post_search to find individual posts. Always provide context and source URLs.`,
  llm: new VercelAIProvider(),
  model: openai("gpt-4o-mini"),
  tools: await mcpConfig.getTools(),
});

// Initialize VoltAgent
const voltAgent = new VoltAgent({
  agents: {
    socialAnalyst,
  },
});
```

## Troubleshooting

<AccordionGroup>
  <Accordion title="MCP Connection Issues">
    **Problem**: Cannot connect to Membit MCP server

    **Solutions**:

    * Verify your API key
    * Check network connectivity and firewall settings
    * Ensure the streamable HTTP endpoint is accessible
    * Try increasing the timeout value in MCPConfiguration
  </Accordion>

  <Accordion title="Tool Loading Failures">
    **Problem**: `mcpConfig.getTools()` returns empty or fails

    **Solutions**:

    * Ensure MCP configuration is correct with proper server settings
    * Check that the Membit API key is valid
    * Verify the MCP server URL is accessible
    * Try initializing the MCP config in a try-catch block
  </Accordion>

  <Accordion title="Workflow Execution Issues">
    **Problem**: Workflows fail or don't execute properly

    **Solutions**:

    * Check agent dependencies and execution order
    * Verify all required agents are properly registered
    * Use structured logging to debug workflow steps
    * Ensure agents have access to required tools
  </Accordion>
</AccordionGroup>

```
```


# FAQs
Source: https://docs.membit.ai/misc/faqs

Find answers to frequently asked questions about Membit.

## General

<AccordionGroup>
  <Accordion title="What is Membit?">
    Membit is a Context-as-a-Service (CaaS) platform that gives your AI agents
    and analytics tools a direct line to what's happening in the world right
    now. We provide a constantly updated knowledge base built from global social
    discussions, so your AI is always equipped with the freshest context.
  </Accordion>

  <Accordion title="How is Membit different from other data providers or social listening tools?">
    Traditional social listening tools are built for marketing dashboards.
    Membit is built for AI. Instead of just raw data, we provide structured,
    high-signal "context" that AI agents can easily understand and use. This
    allows you to build applications that don't just report on the "what," but
    understand the "why" behind real-time events.
  </Accordion>

  <Accordion title="Who is Membit for?">
    Membit is for anyone building with AI who needs access to real-time world
    context. It's especially powerful for:

    * **AI Developers & Agent Builders:** Create smarter, more aware
      applications.
    * **Financial Analysts:** Spot market-moving trends and sentiment shifts as
      they emerge.
    * **Media & Content Creators:** Discover viral stories and generate timely
      content.
    * **Brands & Marketers:** Monitor brand health and gain competitive
      intelligence.
  </Accordion>

  <Accordion title="Is Membit free to use during the beta period?">
    Yes! During our beta, Membit is free for both personal and business use. We
    provide a generous starting allocation of API credits, and you can request
    more anytime by joining our [Discord](https://discord.bandprotocol.com)
    community.
  </Accordion>
</AccordionGroup>

## For Data Hunters

<AccordionGroup>
  <Accordion title="What is the Membit Data Hunter program?">
    The Membit Data Hunter program is a decentralized community that rewards you
    for helping build a real-time context layer for AI. Using our browser
    extension, you can gather public social data that makes AI models smarter
    and more aware of current events. In return for your contributions, you earn
    points and status.
  </Accordion>

  <Accordion title="What kind of content qualifies?">
    We look for high-signal, timely, and publicly available content. Think
    breaking announcements, expert analysis, and emerging trends. The goal is to
    capture credible information that adds real value to a discussion and helps
    AI understand the world more accurately.
  </Accordion>

  <Accordion title="How does the rewards system work?">
    You earn points for every piece of valuable data you contribute. Our system
    rewards you for both the quality of the information and for being early to
    spot a trend. Points can be redeemed for perks like API credits, and top
    contributors get recognized on our global leaderboard.
  </Accordion>

  <Accordion title="How is my contribution reviewed and used?">
    Your contributions go through our automated pipeline where AI validates each
    post, filters out noise, and groups related content into "discussion
    clusters." This structured context is then made available to developers, who
    use it to build smarter, context-aware AI applications.
  </Accordion>

  <Accordion title="What about privacy and data usage?">
    Your privacy is a core principle. The extension only processes publicly
    available data. It does not access private messages, personal profiles, or
    paywalled content. You participate as a pseudonymous contributor, and we do
    not sell personal user data.
  </Accordion>

  <Accordion title="How do I get started and contribute effectively?">
    Install the Chrome extension and browse the web as you normally would. To
    maximize your rewards, focus on your areas of expertise. Your unique
    knowledge helps you spot high-signal content that others might miss,
    increasing the value of your contribution to the network.
  </Accordion>

  <Accordion title="Why aren’t my points increasing even though I keep scrolling on social media?">
    This might happen if our system detects unusual activity on your account.
    For example, sending fake posts directly to the Membit API could temporarily
    pause point accumulation. If you believe this was a mistake, please reach
    out to our support team or email us at [membit@bandprotocol.com](mailto:membit@bandprotocol.com) so we can
    assist you.
  </Accordion>
</AccordionGroup>

## For Developers & API Users

<AccordionGroup>
  <Accordion title="How can I access Membit's data?">
    We offer several ways to access our data to fit your workflow. You can use
    our straightforward RESTful API, connect to our MCP server for real-time
    streams, or use our official client libraries for Python and TypeScript.
  </Accordion>

  <Accordion title="What kind of data can I get from the Membit API?">
    The API provides access to structured "discussion clusters." These are
    collections of related social media posts, articles, and other content
    centered around a specific topic or event. Your AI agents can search for
    these clusters using natural language and then dive into the underlying
    content to understand what real people are saying and how conversations are
    evolving.
  </Accordion>

  <Accordion title="How up-to-date is the data?">
    Our data is updated continuously. Our global network of Data Hunters
    contributes new content 24/7, and we run our clustering and analysis
    pipeline every hour. This ensures the context you provide to your AI is
    always fresh and relevant.
  </Accordion>

  <Accordion title="What are API credits and how are they calculated?">
    During our beta, every user starts with 500 API credits and receives an
    additional 100 credits each day. Credits are used to pay for API calls, with
    different endpoints having different costs based on their complexity. This
    system ensures you only pay for the value you receive.
  </Accordion>

  <Accordion title="Are there rate limits for the API?">
    Your usage is primarily governed by your available API credits rather than a
    traditional requests-per-second rate limit. As long as you have credits, you
    can make calls. If you have high-volume needs, please
    [reach out to us on Discord](https://discord.bandprotocol.com) to discuss a
    custom plan.
  </Accordion>

  <Accordion title="What integrations are available for Membit?">
    Membit is designed to integrate seamlessly into your existing stack. We have
    guides and examples for popular frameworks, including:

    **No-Code AI Agents:**

    * [n8n](/integrations/no-code-agent-frameworks/n8n)
    * [Gumloop](/integrations/no-code-agent-frameworks/gumloop)
    * [Flowise](/integrations/no-code-agent-frameworks/flowise)
    * [Langflow](/integrations/no-code-agent-frameworks/langflow)
    * [Cursor](/integrations/no-code-agent-frameworks/cursor)

    **Python Agents:**

    * [CrewAI](/integrations/python-agent-framework/crewai)
    * [LangChain](/integrations/python-agent-framework/langchain)
    * [LlamaIndex](/integrations/python-agent-framework/llamaindex)
    * [AutoGen](/integrations/python-agent-framework/autogen)

    **Typescript Agents:**

    * [Mastra](/integrations/typescript-agent-framework/mastra)
    * [Voltagent](/integrations/typescript-agent-framework/voltagent)
  </Accordion>

  <Accordion title="Can I request a custom data pipeline or specific data sources?">
    Absolutely. We understand that some applications have unique data
    requirements. If you need a custom data pipeline or access to specific
    sources not currently in our network, please
    [reach out on Discord](https://discord.bandprotocol.com) to discuss your needs
    with our team.
  </Accordion>
</AccordionGroup>


# Cluster Info
Source: https://docs.membit.ai/playground/cluster-info

/openapi.json get /clusters/info
Get detailed information about a specific cluster, including individual posts.



# Search Clusters
Source: https://docs.membit.ai/playground/search-clusters

/openapi.json get /clusters/search
Search for trending discussion clusters using semantic and keyword matching.



# Search Posts
Source: https://docs.membit.ai/playground/search-posts

/openapi.json get /posts/search
Search for individual social media posts using semantic similarity.



# Use Cases
Source: https://docs.membit.ai/use-cases

Discover how Membit can be used to power a new generation of context-aware applications.

Membit's real-time context can be applied to a wide range of use cases, from financial trading to brand management. Here are a few examples of how you can leverage Membit to build smarter, more responsive applications.

## Trend Spotting

<Card title="Uncover Crypto Alpha" icon="chart-mixed">
  Stay ahead of the market by identifying emerging narratives and sentiment
  shifts in real-time. Set up automated alerts to catch the next 10x gem before
  it goes mainstream, turning social chatter into actionable trading signals.
</Card>

<Card title="Fuel Your Content Engine" icon="newspaper">
  Never miss a viral moment. Automatically pull the day's hottest topics from
  Membit, use AI to summarize them into content briefs, and deliver them
  straight to your editorial team's workspace.
</Card>

<Card title="Monitor Your Product Launch" icon="rocket">
  Track real-time reactions to your product launch without writing a single line
  of code. Instantly identify and triage negative feedback while surfacing
  positive highlights to celebrate with your marketing team.
</Card>

## Disaster Detection

<Card title="Anticipate Supply Chain Disruptions" icon="ship">
  Leverage local Data Hunters to monitor specific geographic areas for signs of
  disruption. Set up geo-fenced filters to receive instant alerts, helping you
  avoid millions in potential losses by rerouting shipments ahead of time.
</Card>

<Card title="Power Real-Time Crisis Mapping" icon="map">
  During emergencies, every second counts. Use Membit to search for posts and
  image tags from crisis zones, then pipe that data directly into a
  public-facing dashboard for first responders and NGOs.
</Card>

<Card title="Build a DeFi Exploit Immune System" icon="shield-check">
  Protect your protocol by monitoring high-threat social clusters for early
  signs of exploits. Automatically trigger governance proposals to pause
  contracts, giving your community time to react and secure funds.
</Card>

## Sentiment Feedback

<Card title="Prevent Brand Crises" icon="building-shield">
  Get ahead of PR nightmares. Monitor for sudden spikes in negative sentiment
  around your brand and use AI to instantly draft a status update for your comms
  team, turning a potential crisis into a proactive response.
</Card>

<Card title="Gauge Early Startup Traction" icon="signal">
  Measure what truly matters after you launch. Get a daily email pulse of user
  sentiment and integrate this feed into your KPI dashboard to see how your
  social traction correlates with product metrics.
</Card>

<Card title="Generate a Competitive Intel Feed" icon="magnifying-glass">
  Turn social chatter into a lead-generation machine. Monitor keywords related
  to your competitors, automatically score leads based on expressed intent, and
  pipe them directly into your CRM for your sales team.
</Card>