# Goldsky MCP > Goldsky (Web3 Data Indexing & Subgraphs) MCP lets you control complex blockchain data pipelines from your chat window. You can list, create, pause, and monitor real-time indexing jobs for Web3 data streams using natural language commands. ## Overview - **Category:** developer-tools - **Price:** Free - **Tags:** web3, subgraphs, data-indexing, ethereum, real-time-data ## Description Managing Web3 data is messy work. It involves building and maintaining pipelines that read raw blockchain feeds and turn them into usable records. This MCP gives you direct control over those Goldsky Turbo pipelines right from your agent interface. You can list every active pipeline, check its current status, or pull detailed execution logs to troubleshoot an issue immediately. If a pipeline hits a snag, you don't have to jump into the web console; you just tell your AI client to validate the definition first, then pause it if needed. This is about making sure your data infrastructure stays alive and accurate without leaving your code editor. It’s built for people who need reliable, real-time visibility on complex cross-chain data flow. ## Tools ### create_pipeline Builds and activates a brand new data indexing pipeline in the project. ### delete_pipeline Permanently removes an existing, obsolete pipeline definition from your account. ### get_pipeline_error_count Calculates the number of errors that occurred in a specified time frame for a pipeline. ### get_pipeline_logs Pulls detailed historical records and debug messages from a running or failed pipeline. ### get_pipeline_state Checks the internal, granular status of a pipeline's execution state. ### get_pipeline_status Provides the current operational runtime status (running, paused, failed) for an indexed job. ### get_pipeline Retrieves detailed metadata for one specific data indexing job. ### list_pipelines Returns a list of every pipeline currently defined within your project. ### pause_pipeline Temporarily halts the execution of an active data indexing stream. ### restart_pipeline Forces a full restart of an existing pipeline job. ### resume_pipeline Reactivates a pipeline that was previously paused. ### validate_pipeline Checks the structure and definitions of a pipeline to ensure it's ready for deployment. ## Prompt Examples **Prompt:** ``` List all my active Goldsky pipelines. ``` **Response:** ``` I've retrieved your pipelines. You have 3 active: 'eth-mainnet-swaps', 'polygon-nft-events', and 'base-bridge-monitor'. Which one would you like to inspect? ``` **Prompt:** ``` Check the status and error count for the pipeline 'eth-mainnet-swaps'. ``` **Response:** ``` The pipeline 'eth-mainnet-swaps' is currently 'RUNNING'. I detected 0 errors in the last time window. Everything looks healthy. ``` **Prompt:** ``` Show me the recent logs for the 'polygon-nft-events' pipeline. ``` **Response:** ``` Fetching logs for 'polygon-nft-events'... [INFO] Successfully indexed block 5420123... [INFO] Processed 12 Transfer events... [DEBUG] Sink connection stable. ``` ## Capabilities ### Check pipeline health and status Get the current operational state of any indexed pipeline—whether it's running, paused, or has failed. ### Manage the pipeline lifecycle Stop a runaway pipeline using pause_pipeline, restart one with restart_pipeline, or resume work when ready. ### Audit and validate definitions Run validate_pipeline to check your source, transformation, and sink definitions for errors before deploying anything. ### List and retrieve pipeline details See all existing pipelines or fetch specific metadata about a single job using list_pipelines and get_pipeline. ### Inspect logs and error counts Pull historical execution logs with get_pipeline_logs, or quantify failures in a time window via get_pipeline_error_count. ## Use Cases ### Debugging a broken data feed The team noticed the NFT event pipeline stopped suddenly. Instead of SSHing into a server, they asked their agent to run get_pipeline_status and then use get_pipeline_logs for that specific job. They found an API key mismatch in the logs and fixed it immediately. ### Preparing for maintenance The ops team needs to update the core data source schema. To prevent corrupted reads, they ran validate_pipeline first. Once validated, they used pause_pipeline before making changes, ensuring zero downtime risk. ### Auditing historical failures A client questioned missing swap records. The developer used get_pipeline_error_count for the last 24 hours on the swaps pipeline to prove that while errors occurred, they were isolated and handled by retries. ### Building a new monitor A product team wants to track a brand new asset type. They used list_pipelines to see what already existed, then called create_pipeline with the new JSON definition, monitoring it via get_pipeline state. ## Benefits - Instant visibility into indexing failures. You can check the current run status and error count with get_pipeline_status and get_pipeline_error_count, letting you know if something broke without digging through console logs. - Full lifecycle control over data streams. Need to update the source? Use pause_pipeline first. When you're done, call resume_pipeline to minimize downtime. - Risk-free deployment workflow. Before running create_pipeline, always use validate_pipeline. This catches bad configurations (sources or sinks) early, preventing costly runtime failures. - Deep troubleshooting access. If the data is wrong, you need context. Use get_pipeline_logs to pull specific execution records and find out exactly which block failed. - Simple project overview. list_pipelines gives you a quick inventory of every job running, so you always know what's active in your cross-chain monitoring setup. ## How It Works The bottom line is you manage complex Web3 data infrastructure using simple conversation, not complicated UI clicks. 1. Subscribe to the MCP and enter your Goldsky API Key. 2. Tell your agent what you need done—for instance, 'List all my active pipelines' or 'Pause the swaps monitor.' 3. The system executes the necessary tool calls (like list_pipelines or pause_pipeline) and returns a clean status update directly to your chat. ## Frequently Asked Questions **How do I check if a pipeline is healthy using get_pipeline_error_count?** get_pipeline_error_count lets you query the number of errors within a specific time window. This gives you quantitative proof of data integrity, which is better than just seeing 'running' status. **Can I use validate_pipeline to check my entire project?** No, validate_pipeline checks the definition of one specific pipeline at a time. You must first use list_pipelines to identify all jobs and then run validation on each one before deployment. **What's the difference between get_pipeline_status and get_pipeline_state?** get_pipeline_status gives you the high-level operational status (running, paused). get_pipeline_state provides deeper internal metrics about how the pipeline is managing its own resources. **How do I delete a pipeline using delete_pipeline?** Calling delete_pipeline removes the job permanently and irreversibly. Always ensure you have backed up any necessary definitions or logs before running this tool. **What's the best way to manage resources using `pause_pipeline` and `resume_pipeline`?** Using pause/resume is ideal for cost control. Pausing a pipeline stops all resource usage instantly, perfect for maintenance or downtime. You can later restart it with `resume_pipeline` without losing its definition. **How do I use `get_pipeline` to view the full schema and configuration of an existing workflow?** The `get_pipeline` tool returns the complete definition, including all sources, transforms, and sinks. This lets you confirm exactly how data is configured to flow before making changes or debugging. **If I don't know which pipelines exist, how do I find them using `list_pipelines`?** `list_pipelines` retrieves an overview of every pipeline defined in your project. This list includes all pipelines, whether they are currently running, paused, or inactive. **What specific errors does `validate_pipeline` check before I deploy a new data flow?** The validation tool checks the structural integrity of the pipeline definition. It ensures your sources, transforms, and sinks match expected schemas, preventing deployment failures due to bad configuration. **Can I check if my pipeline configuration is valid before deploying it?** Yes! Use the `validate_pipeline` tool with your definition object. It will check your sources, transforms, and sinks for errors without actually starting a new pipeline. **How do I monitor errors in a running pipeline?** You can use `get_pipeline_error_count` to see the number of issues in a time window, or `get_pipeline_logs` to fetch the actual execution logs for detailed debugging. **Is it possible to temporarily stop a pipeline without deleting it?** Absolutely. Use the `pause_pipeline` tool to stop execution. When you are ready to start again, simply use the `resume_pipeline` tool.