# YepCode MCP MCP

> YepCode lets your agent run complex serverless code snippets and manage cloud workflows entirely through conversation. List processes, trigger data syncs with custom parameters, and monitor execution history—all without touching a dashboard or writing boilerplate API calls.

## Overview
- **Category:** ship-it
- **Price:** Free
- **Tags:** serverless, workflow-automation, data-integration, cloud-functions, process-control

## Description

This MCP connects your AI client directly to YepCode's engine for running external code and automating data tasks. Instead of logging into a separate cloud console or manually crafting complex JSON payloads, you talk to your agent and it handles the whole sequence.

Need to run an ETL process? Your agent can trigger that workflow, pass specific parameters like a date range, and track if it succeeded or failed. If your automation needs to pull user data from this flow and then send it via another service—say, logging results into a separate messaging MCP—you can chain them together. This is where the power lies; you build multi-step automations that span platforms using one AI agent. Plus, because Vinkius manages every call through a zero-trust proxy, your API keys are used only in transit and never stored on disk. It’s built for reliable, secure operations.

## Tools

### get_process_details
Retrieves detailed information about a single YepCode workflow process.

### list_executions
Pulls a list of the most recent times any configured processes were run.

### list_processes
Lists all the available serverless workflows you have set up in your account.

### list_secrets
Displays a list of credentials and secrets used by your automations for reference.

### list_teams
Shows which development teams or workspaces are available within your account structure.

### run_process
Starts an active execution of a chosen YepCode workflow with custom input parameters.

## Prompt Examples

**Prompt:** 
```
Show me all available processes in my YepCode account.
```

**Response:** 
```
I've retrieved your processes. You have 5 serverless workflows configured, including 'Database Sync', 'PDF Generator', and 'Slack Notifier'. Which one would you like to run?
```

**Prompt:** 
```
Run the 'Data Export' process with the parameter { "format": "csv" }.
```

**Response:** 
```
Process triggered! The 'Data Export' execution has started with ID exe_12930. I'll let you know when the history shows it's complete.
```

**Prompt:** 
```
Check the status of my recent process executions.
```

**Response:** 
```
Inspecting recent executions... I found 3 entries: 'PDF Generator' (Success), 'Database Sync' (Success), and 'Web Scraper' (Error). Would you like the error logs for the Web Scraper?
```

## Capabilities

### List all available workflows
See exactly which serverless processes you've set up without having to navigate the YepCode console.

### Trigger a specific process run
Execute any configured workflow, passing in necessary variables like file names or IDs for that specific job.

### Check recent execution status
Review the history of runs to confirm if your jobs finished successfully or pinpoint where they broke.

### Retrieve process configuration details
Get deep information on how a specific workflow is built, including its required parameters and logic.

### View account secrets
List existing credentials used by your automations to verify availability without exposing the actual secret values.

## Use Cases

### The End-of-Day Data Audit
A data analyst needs to confirm that last night's sync ran correctly. Instead of diving into the YepCode dashboard, they ask their agent to check recent runs using `list_executions`. The agent immediately reports back if the 'Database Sync' process succeeded or hit an error.

### The Hotfix Deployment
A DevOps engineer needs to run a maintenance script immediately. They tell their agent, 'Run the nightly cleanup job with the parameter format=csv.' The agent uses `run_process` and kicks off the workflow instantly.

### Onboarding New Developers
A software developer needs to know what workflows exist in a new project. They ask their agent, 'What processes are available?' The agent calls `list_processes`, giving them an immediate inventory of all usable code snippets.

### Validating Dependencies
A security team member needs to ensure the production environment hasn't lost access keys. They ask their agent to list secrets, using the `list_secrets` tool to verify that credentials are still present and valid.

## Benefits

- Stop manually running jobs. You can use the `run_process` tool to trigger complex workflows instantly, just by telling your agent what needs doing.
- Track everything with confidence. The `list_executions` tool lets you check process history and see if a job finished successfully or failed out.
- Keep credentials safe. Use `list_secrets` to verify necessary account secrets are available without ever exposing the actual key values.
- Understand your environment. You can use `list_processes` to get an inventory of all your existing workflows, so you never forget which one exists.
- Manage permissions easily. The `list_teams` tool helps you understand which development teams or workspaces are configured in your account.

## How It Works

The bottom line is you get to automate complex backend processes using natural language prompts.

1. Subscribe to this MCP and provide your YepCode API key.
2. Tell your agent what needs doing; for example, 'Run the PDF generator process with a user ID of 102'.
3. The agent calls the required tool, executes the code, and returns the status or result directly in the chat.

## Frequently Asked Questions

**Can I provide input parameters when running a process?**
Yes, the `run_process` tool accepts an optional JSON object for parameters, allowing you to pass dynamic data to your serverless functions.

**How do I check if a process execution failed?**
Use the `list_executions` query. It will return a history of recent runs along with their final status (e.g., success, error, pending).

**Is it possible to see the code of my processes via AI?**
Yes, you can use the `get_process_details` tool to retrieve the complete metadata and code configuration for any specific process ID.

**When I use the `list_secrets` tool, how does Vinkius ensure my account secrets remain private?**
Vinkius never stores your actual keys on disk. The system verifies the secret's existence and list its names using a zero-trust proxy during transit only.

**Before I trigger a workflow, how do I use `list_processes` to see all available serverless workflows?**
You call `list_processes` with no parameters. This returns a full list of every configured process name and its basic description in your YepCode account.

**If my company has multiple projects, how does the `list_teams` tool help me narrow down the correct development scope?**
`list_teams` shows all available teams and workspaces associated with your API credentials. This lets you ensure your agent is running against the right development environment.

**What are the limitations or retention periods when I use `list_executions` to check past process runs?**
The tool lists recent executions, providing a detailed history of status and IDs. The system keeps these records for auditing purposes, but there is an internal limit on how far back you can look.

**If I need the technical metadata—not just running it—how does `get_process_details` assist me?**
`get_process_details` pulls comprehensive information about a specific process. This includes parameters, expected outputs, and workflow descriptions without needing to trigger an actual run.