# Mokaform MCP

> Mokaform connects form building and data capture directly into your agent workflow. It lets you create interactive surveys with visual logic builders that change questions based on previous answers. Use it to manage forms across workspaces, read every response submission, or update fields without leaving your chat client.

## Overview
- **Category:** productivity
- **Price:** Free
- **Tags:** form-builder, data-collection, survey-automation, response-management, no-code, data-entry

## Description

Yo. This Mokaform MCP Server lets your AI client handle all your form building and data collection straight from the chat window. You never gotta open up the web UI or deal with clunky menus again; you just talk to your agent, and it makes it happen.

Your agent uses this server to manage every aspect of Mokaform—from drafting a brand-new survey to wiping out old responses. It's all about getting structured data into your workflow without leaving the chat client.

### Building and Structuring Forms

Need a new form? You kick off the process using `create_form`, which builds and saves a whole template for you in minutes. Once that’s done, you can keep an eye on what you got with `list_forms` to see every active or archived survey sitting in your account. If you need to adjust something—maybe change a required field or tweak the logic—you run `update_form`. This lets you modify settings, fields, and even the flow of an existing form template without having to click around in a GUI.

For deep dives into what's already set up, you can use `get_form` to pull the entire configuration and all the details for one specific form ID. It’s like pulling up the blueprint before you start building. And if you gotta know which organizational buckets your forms live in, run `list_workspaces`; that shows every distinct container where your data is stored.

### Handling Responses and Data

When it comes to data, there are a few ways you'll want to play around. You can grab all the full details for one single submitted form record using `get_response`. This fetches every piece of data point associated with that specific submission ID. But if you're doing reporting or just wanna see everything that came through, `list_responses` gathers a paginated list of *all* submissions tied to a given form ID. That’s killer for reports.

To get an overview of all the raw data collected across every single survey in your account, run `list_forms`, and you'll see the templates that generate those responses. You can also pull a full list of every submitted response record by running `list_responses` against a specific form ID.

### Cleanup and Control

Sometimes you just gotta clear out the junk. If there’s an outdated or incorrect submission, you use `delete_response` to permanently remove that single, bad record from the system. You're in full control of your data hygiene with this one.

Basically, you tell your agent what you want—whether it's building a whole new survey via `create_form`, checking the structure of an old one using `get_form`, pulling up every response for reporting purposes with `list_responses`, or cleaning house by deleting garbage submissions. It manages all that heavy lifting in plain conversation.

## Tools

### create_form
Builds and saves a brand new form template within Mokaform.

### delete_response
Permanently removes a single, specific submitted response record.

### get_form
Retrieves the full configuration and details for one specified form ID.

### get_response
Fetches all data points from a single completed form submission.

### list_forms
Returns a list of every active and archived form template available in your account.

### list_responses
Gathers a paginated list of all submitted responses for a given form ID.

### list_workspaces
Displays all the distinct organizational containers (workspaces) where your forms are stored.

### update_form
Modifies the settings, fields, or logic of an existing form template.

## Prompt Examples

**Prompt:** 
```
List all forms and show their response counts.
```

**Response:** 
```
Forms: 4. 1) 'Customer Feedback' (ID: frm_123, 145 responses). 2) 'Job Application' (ID: frm_456, 23 responses). 3) 'Event RSVP' (ID: frm_789, 89 responses). 4) 'Feature Request' (ID: frm_012, 34 responses). Workspace: 'Default'.
```

**Prompt:** 
```
Show the latest 3 responses for the Customer Feedback form.
```

**Response:** 
```
Latest responses (frm_123): 1) Sarah T. — Rating: 5/5, Comment: 'Love the new dashboard!' (2h ago). 2) Mike L. — Rating: 3/5, Comment: 'Onboarding could be faster.' (5h ago). 3) Lisa R. — Rating: 4/5, Comment: 'Great support team!' (1d ago).
```

**Prompt:** 
```
Create a new feedback form in the Marketing workspace.
```

**Response:** 
```
Form created! ✅ Title: 'Product Feedback Q2'. ID: frm_345. Workspace: 'Marketing'. Status: Draft. Ready to add fields and publish.
```

## Capabilities

### Build New Forms
Use `create_form` to define a new survey or collection tool in minutes.

### Manage Form Structures
Modify existing forms using `update_form` without manual UI steps.

### View All Forms and Workspaces
List all available form templates or list the workspaces they live in using `list_forms` and `list_workspaces`.

### Retrieve Specific Submissions
Grab full details for one single response record with `get_response`.

### Batch Response Retrieval
List every response submitted to a specific form using `list_responses`, perfect for reporting.

### Cleanup Submissions
Remove unwanted or outdated responses from the system via `delete_response`.

## Use Cases

### Reviewing Job Applicants
The HR manager needs to see all job applications from last week. They ask their agent, 'Show me responses for the 'Job Application' form.' The agent calls `list_responses` and gives them a summary of 23 submissions, allowing them to quickly identify the candidates who haven't responded yet.

### Launching a New Feature Survey
A Product Manager wants to test new pricing models. They first use `list_workspaces` to find the 'Beta Testing' area, then call `create_form` to build a clean survey template for that workspace. Finally, they share the link and track submissions using `get_response`.

### Correcting Bad Data
A marketer realizes an old survey form ('Event RSVP') is still active but contains bad data entries. They call `list_forms` to confirm the ID, then use `update_form` to disable the form and remove the problematic entries using `delete_response`.

### Comparing Multiple Projects
A team lead needs to compare feedback across three different product lines. They ask their agent to list all forms (`list_forms`) and then run `get_form` for each one, consolidating the titles and field structures into a single comparison report.

## Benefits

- **Build fast:** Use `create_form` to roll out new feedback surveys instantly. You don't need a developer to write basic CRUD endpoints—you just describe the form, and it gets built.
- **Audit data easily:** When you need all submissions for Q3, run `list_responses`. This pulls every record into your agent, allowing immediate analysis without exporting CSVs.
- **Maintain accuracy:** Use `get_form` before making changes. You can pull the current definition to confirm exactly which fields and logic rules are active before calling `update_form`.
- **Keep data separate:** Need to segment forms for different departments? Call `list_workspaces` first. This keeps your HR forms totally isolated from your Marketing surveys.
- **Fix mistakes instantly:** If a submission is incorrect or leaked, run `delete_response`. It handles the removal of that specific record cleanly.

## How It Works

The bottom line is, you treat form management like chatting with a colleague: you just tell it what you need done.

1. First, subscribe to this server and input your Mokaform API Key into your client.
2. Next, ask your agent a command—like 'List all forms in the HR workspace'—and let it run `list_forms` or `list_workspaces`.
3. The system returns the data structure for your request (e.g., 4 active forms), which you can then use to target specific actions like calling `get_response`.

## Frequently Asked Questions

**How do I get all my submitted form responses using list_responses?**
`list_responses` gathers every submission for a specific form ID. You just need to tell the agent which Form ID you want data from, and it handles pagination.

**Can I change an existing form without losing its settings using update_form?**
Yes, `update_form` lets you modify fields or logic. However, always use `get_form` first to grab the current JSON structure; this ensures you pass a complete payload and don't break anything.

**How do I find out which workspaces I have? Do I need list_workspaces?**
You use `list_workspaces`. This tool shows every container where your forms are stored. It's critical to run this before you try to create or update a form, so you know the correct scope.

**What is the difference between get_response and list_responses?**
`list_responses` gives you a summary view of every record for a whole form. `get_response`, however, drills down to give you all the detailed data points (e.g., rating, comments) from one specific submission.

**If I use `delete_response`, am I sure that data is permanently gone?**
Yes, deleting a form response removes it entirely and cannot be recovered. The tool executes the deletion immediately upon confirmation; there's no soft-delete or trash bin feature to restore the record.

**How does `get_form` help me understand the structure of a form compared to just using `list_forms`?**
`Get_form` returns the full schema, including every field type and validation rule. While `list_forms` only gives you the name and ID, `get_form` shows exactly how the dynamic logic works.

**What parameters do I need to provide when running `create_form`?**
You must provide a unique title and specify which workspace should host the new form. The tool requires these identifiers to ensure the form is properly scoped and organized from the start.

**When I use `list_workspaces`, what does that tell me about data isolation?**
This function shows you all the top-level containers where your forms live. Workspaces isolate your efforts, meaning forms and responses in one workspace won't affect those in another.

**Can I create and collect form responses?**
Yes. Create forms programmatically, then list and read all submissions with full field data.

**What API does Mokaform use?**
Mokaform uses Bearer authentication against `api.opnform.com/v1`.

**Can I organize forms into workspaces?**
Yes. List and manage workspaces to keep forms organized by project or team.