At viaSocket, we believe in empowering our users to create and automate workflows without restrictions. We want you to leverage our platform to its full potential, without being limited by arbitrary thresholds.

Our goal is to provide a smooth and efficient experience, so you can focus on building intelligent and seamless integrations.

Guiding Principles

While we do not impose hard usage limits on the number of requests or the volume of interactions you can have through viaSocket's Model Context Protocol (MCP), we ask that users adhere to the following guidelines to ensure that everyone can benefit from a fair and efficient service:

1. Responsible Usage: We encourage users to interact with the platform in a manner that does not impact the experience of others. Excessive or malicious usage that disrupts the platform or its services may be subject to review.

2. Security and Integrity: Ensure that your usage complies with our security standards. We prohibit any activity that would compromise the platform’s integrity, including, but not limited to, unauthorized data scraping, attacks, or any other forms of malicious activities.

3. Fairness: While we don’t set hard caps, please avoid automating actions that could unintentionally overload the system, such as excessive API calls or spam-like behaviors. Use the platform responsibly to maintain optimal performance for all users.

4. Compliance: Users must ensure that they are in compliance with all applicable laws and regulations, including but not limited to data privacy laws like GDPR, CCPA, and others. All data processed via the platform must be done with the necessary permissions and rights.

What We Do Not Tolerate

We take violations of our terms seriously. The following activities are strictly prohibited and could lead to suspension of access to viaSocket MCP:

• Malicious Activity: Including attempts to exploit the platform or compromise its security.

• Misuse of Data: Engaging in any activity that violates data privacy or intellectual property laws.

• Spamming or Fraudulent Behavior: Sending unsolicited communications or attempting to mislead others.

• Service Disruptions: Engaging in any actions that would intentionally degrade the quality or availability of the service for other users.

A Commitment to Growth

We are dedicated to growing alongside our users. We understand that as you scale your business, your needs may evolve. If your usage is expanding beyond typical operations, or if you require additional support or resources, we are here to help.

Please reach out to our support team at

[email protected]

Easily use AI Actions within Cursor IDE with viaSocket MCP. Let your AI assistant handle real-world tasks securely, all without leaving your coding environment.

Quick Start

Get started with Cursor and AI Actions in just three easy steps:

1. Copy your unique MCP server URL from the “viaSocket MCP”

2. Choose the actions you want your AI to access.

3. Open Cursor and paste the MCP URL.

You're ready to go!

Configuring viaSocket MCP in Cursor

For Cursor version ≥ 0.46 (recommended), follow these steps to configure viaSocket MCP:

1. Open Cursor settings (⇧+⌘+J).

2. Navigate to the "MCP" tab and click "Add MCP Server".

3. Add the following JSON configuration, replacing the placeholder URL with your MCP URL.

{
  "mcpServers": {
    "viasocket MCP": {
      "url": "https://mcp.viasocket.com/****************/sse"
    }
  }
}

Caution: Treat your MCP server URL like a password! It can be used to run your AI actions and access your data.

You can now use viaSocket MCP directly with Claude Desktop by Anthropic. This lets Claude Desktop perform real-world tasks, like sending messages or creating events, through a simple and secure connection, expanding its capabilities beyond just conversations.

Quick Start

Three simple steps to get started with Claude Desktop and AI Actions:

1. Copy your unique MCP server URL into the

   viaSocket MCP.

2. Choose and configure the actions you want Claude Desktop to access.

3. Configure Claude Desktop with your MCP URL (see instructions below).

Configuring viaSocket MCP in Claude Desktop

Include the following JSON configuration in claude_desktop_config.json, replacing the placeholder URL with your actual MCP URL from the MCP settings:

{
  "mcpServers": {
    "viasocket-mcp": {
      "command": "npx",
      "args": [
        "mcp-remote",
        "https://mcp.viasocket.com/************/sse"
      ]
    }
  }
}

You can now use viaSocket MCP directly from Windsurf IDE. This lets your AI assistant perform real-world tasks through a simple, secure connection, all without leaving your coding environment.

Quick Start

Here are three simple steps to get started with Windsurf and viaSocket MCP:

1. Copy your unique MCP server URL from the viaSocket MCP in your workspace.

2. Configure the actions you want your AI to access.

3. Open Windsurf and add the MCP URL in the settings.

Configuring MCP in Windsurf

To set up MCP with Cascade:

1. Go to Windsurf - Settings > Advanced Settings or open the Command Palette and select Open Windsurf Settings Page.

2. Scroll down to the Cascade section.

3. Here, you can add a new server, view existing servers, and access the raw JSON config file at mcp_config.json.

Adding a New Server

To add a new server:

1. Click the "Add Server" button in the Cascade settings.

2. Choose from the pre-populated popular servers or click "Add custom server +" to add your own server directly in mcp_config.json.

mcp_config.json

The mcp_config.json file, located at ~/.codeium/windsurf/mcp_config.json, lists the servers Cascade can connect to.

The JSON format should match the same schema as the config file for Claude Desktop.

Here’s an example configuration for viaSocket MCP:

{
  "mcpServers": {
    "viasocket Actions MCP": {
      "serverUrl": "https://mcp.viasocket.com/*************/sse"
    }
  }
}

AI Agent Action Methods: MCP vs viaSocket Embed

There are two primary ways for AI agents to take actions:

1. MCP (Model Context Protocol)

2. viaSocket Embed
   

Both methods offer unique advantages depending on the specific use case of your platform. Below is a detailed comparison of the two approaches:

MCP (Model Context Protocol)

In this model, your platform will operate as an MCP client, and the user is responsible for finding and connecting to an MCP server. This approach is best suited for scenarios where the AI agent is solving a broad, general-purpose problem and the types of actions users might take are unpredictable.

viaSocket Embed

This method is characterized by the tight coupling of both the platform and the AI agent within the same environment, streamlining the process significantly. It’s ideal when your AI agent is designed to address specific industry problems and you can anticipate the actions users may need.

Quick Comparison Guide :

Bring Your Own MCP Client

If you choose to bring your own MCP client, you can provide your users with our MCP server link:

https://viasocket.com/mcp

This service is

free with fair usage policies.

Conclusion:

• MCP is ideal for general-purpose AI agents that require flexibility but come with the trade-off of complexity and user maintenance.
  

• viaSocket Embed, on the other hand, provides a streamlined, user-friendly experience with less complexity, making it perfect for industry-specific AI agents where actions can be anticipated and controlled.
  
  

Use the Python client to connect to a viaSocket MCP server for efficient tool management and data access.

Installation

To install the required package:

pip install fastmcp

Or with uv support:

uv pip install fastmcp

Usage Example

import asyncio
import json
from fastmcp import Client
from fastmcp.client.transports import StreamableHttpTransport

# Replace with your viaSocket MCP server URL
server_url = "https://mcp.viasocket.com/****************/sse"
transport = StreamableHttpTransport(server_url)

# Initialize the client
client = Client(transport=transport)

async def main():
    async with client:
        print("Client connected:", client.is_connected())

        # Fetch available tools
        tools = await client.list_tools()
        print(f"Available tools: {json.dumps([t.name for t in tools], indent=2)}")

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

Notes:

• Server URL: Replace server_url with your viaSocket MCP server URL.

• Tools Fetching: The list_tools() method fetches available tools from your MCP server.

This setup will connect to the viaSocket MCP server and list available tools.

Use the TypeScript client to connect to your MCP server.

Installation

To install the required package:

npm install @modelcontextprotocol/sdk

Or with pnpm:

pnpm add @modelcontextprotocol/sdk

Caution: Treat your MCP server URL like a password! It can be used to run tools attached to this server and access your data.

Usage Example

import { Client } from "@modelcontextprotocol/sdk/client/index.js";
import { SSEClientTransport } from "@modelcontextprotocol/sdk/client/sse.js";

// Initialize the client with your details
const client = new Client(
  {
    name: "mcp-typescript-client",
    version: "1.0.0",
  },
  {
    capabilities: {},
  }
);

// Replace with your viaSocket MCP server URL
const serverUrl =
  "https://mcp.viasocket.com/****************/sse";
const transport = new SSEClientTransport(new URL(serverUrl));

async function main() {
  // Connect to the server
  console.log("Connecting to viaSocket MCP server...");
  await client.connect(transport);
  console.log("Connected to viaSocket MCP server");

  // List available tools
  console.log("Fetching available tools...");
  const tools = await client.listTools();

  console.log("Available tools:", tools);
  // Tools returned would look like:
  //   No custom tools available yet. Add tools via the MCP UI.

  // Add tools to the server when none are configured
  console.log('No tools configured. Adding a sample tool...');
  const result = await client.callTool({
    name: 'add_tools',
    arguments: {
      instructions: "Add a new tool to the server"
    },
  });
  console.log("Add tools result:\n", result);

  // Close the connection
  await client.transport?.close();
  await client.close();
}

main();

Notes:

• Server URL: Replace serverUrl with your viaSocket MCP server URL.

• Tools Fetching: The listTools() method fetches available tools from your MCP server. If no tools are configured, you can add them with the callTool() method.

This setup will connect to the viaSocket MCP server, list available tools, and allow you to add new tools to the server.