MCP Chat

To run the application on your local machine, follow these steps:

1. Setup Environment Variables: Copy the example environment file and populate it with your credentials:

   cp .env.example .env

   Note: By default, DISABLE_AUTH=true and DISABLE_PERSISTENCE=true are set in the example file to simplify local development.

2. Install Dependencies: Use asdf to manage core dependencies and pnpm to install project packages:

   asdf install
   pnpm install

3. Start the Development Server:

   pnpm dev

The app will be available at http://localhost:3000.

You can one-click deploy this application to Vercel. When deploying, you must provide the following environment variables:

• PIPEDREAM_CLIENT_ID
• PIPEDREAM_CLIENT_SECRET
• PIPEDREAM_PROJECT_ID
• PIPEDREAM_PROJECT_ENVIRONMENT
• AUTH_SECRET
• GOOGLE_CLIENT_ID
• GOOGLE_CLIENT_SECRET
• OPENAI_API_KEY
• EXA_API_KEY
• POSTGRES_URL

To enable saving chat history and user data during local development, you must run a local database using Docker and execute the database migrations.

1. Start local services:

   docker compose up -d

2. Run migrations: Provide your local POSTGRES_URL when running the migration command:

   POSTGRES_URL=postgresql://postgres@localhost:5432/postgres pnpm db:migrate

Before running or deploying MCP Chat, ensure you have the following:

• A Pipedream account.
• A Pipedream project (used to store accounts connected via MCP).
• Pipedream OAuth credentials.
• An OpenAI API key.

Pipedream Chat uses three distinct modes of task handling:

1. Direct Knowledge: Used for general information, simple calculations, creative writing, or explaining technical concepts that don't require real-time data.
2. web_search tool: Used for current events, weather, up-to-date prices/statistics, fact-checking, or recent product details.
3. Pipedream tools: Used for any task requiring integration with external apps, checking/updating data in connected platforms, or performing actions that require authentication (e.g., sending a Slack message).

Multi-step Task Pattern

For tasks requiring both real-time info and API integration (e.g., "Get current weather and send to Slack"), you must always gather real-time information first using web_search before proceeding to use Pipedream tools.

When generating Python code snippets, follow these constraints to ensure they are safe and executable:

• Self-contained: Snippets must be complete and runnable on their own.
• Standard Library Only: Avoid external dependencies; use only the Python standard library.
• Output: Use print() statements to display results.
• Conciseness: Keep snippets generally under 15 lines.
• Safety:
  • Do not use input() or interactive functions.
  • Do not access files or network resources.
  • Do not use infinite loops.
• Error Handling: Handle potential errors gracefully.

# Example of a good snippet
# Calculate factorial iteratively
def factorial(n):
    result = 1
    for i in range(1, n + 1):
        result *= i
    return result

print(f"Factorial of 5 is: {factorial(5)}")

When executing Python code that uses matplotlib, the codeArtifact injects a specific handler to ensure plots are captured and displayed. The handler performs the following steps:

1. Clears existing plots: Calls plt.clf() and plt.close('all').
2. Switches to 'agg' backend: Uses plt.switch_backend('agg') for non-interactive rendering.
3. Customizes plt.show: Overrides the default plt.show() with a custom_show() function that:
   • Checks if the plot size is excessively large and reduces DPI if necessary.
   • Saves the plot to a BytesIO buffer as a PNG.
   • Prints the result as a base64 data URI: data:image/png;base64,<data>.

This allows the client-side console to detect the data:image/png;base64 prefix and render the output as an image rather than text.

To find and use the correct integration tools, follow this sequence:

1. Call the WHAT_ARE_YOU_TRYING_TO_DO tool to find relevant tools.
2. Call the SELECT_APPS tool (which becomes available after the first step) to identify the specific integration to use.
3. Use the list of tools provided by SELECT_APPS to complete the request.

When using Pipedream tools, certain tools initiate a configuration session (indicated by names starting with begin_configuration_). Follow this workflow:

1. Start Session: Call the begin_configuration_* tool.
2. Fetch Options: The tool list will update. Use configure_component to fetch available options for required properties. If a tool provides ASYNC_OPTIONS_*, you must use it to fetch options to avoid invalid data.
3. Execute: Once all required properties are configured, call the run_* tool to execute the action.

Note: If a tool has an empty inputSchema (no required properties), call the run_* tool immediately after the configuration tool.

The project uses Drizzle ORM with PostgreSQL. The configuration is defined in drizzle.config.ts and relies on environment variables loaded from .env.local.

Key configuration settings:

• schema: Points to the database schema definition at ./lib/db/schema.ts.
• out: Specifies the directory for migrations at ./lib/db/migrations.
• dialect: Set to postgresql.
• dbCredentials.url: The connection string is provided via the POSTGRES_URL environment variable.

import { config } from 'dotenv';
import { defineConfig } from 'drizzle-kit';

config({
  path: '.env.local',
});

export default defineConfig({
  schema: './lib/db/schema.ts',
  out: './lib/db/migrations',
  dialect: 'postgresql',
  dbCredentials: {
    url: process.env.POSTGRES_URL!,
  },
});

The postgres service uses the postgres:latest image. It is configured with POSTGRES_HOST_AUTH_METHOD: trust for authentication and exposes port 5432 on the host.

postgres:
  image: postgres:latest
  container_name: postgres_db
  environment:
    POSTGRES_HOST_AUTH_METHOD: trust
  ports:
    - "5432:5432"