# Knack MCP MCP

> Knack MCP connects your AI client directly to your no-code database. It gives your agent the ability to perform full Create, Read, Update, and Delete (CRUD) operations on any Knack object. Instead of building custom APIs or navigating complex dashboards, you just ask your AI client to manage records using plain conversation. You get instant access to all data structures, allowing immediate querying, updating fields, and managing bulk data without ever leaving the chat window.

## Overview
- **Category:** developer-tools
- **Price:** Free
- **Tags:** no-code, database-management, crud-operations, schema-discovery, data-modeling, business-apps

## Description

Need to work with a no-code database but hate writing API calls? This MCP lets your agent talk directly to Knack. You can treat your entire database like an extension of your conversation—no need for complex developer setups or manual dashboard navigation. Your AI client handles schema discovery, so you always know which fields exist before making changes. Want to find a specific customer profile that only exists in 'object_3'? Just ask it. Need to update fifty records at once? Give the agent the structured data and let it run the batch operation. Everything is contained, secure, and managed through natural conversation. Connecting via Vinkius means you get this full database control from one spot, letting your AI client manage Knack without any extra setup.

## Tools

### list_objects
The agent lists every available database collection (object) within the Knack application. This helps you find the Object Key.

### get_object_schema
It returns the metadata for a chosen Knack object, letting you verify its name and high-level structure before proceeding.

### list_records
You provide an object key, and this tool pulls a list of all existing records in that specific Knack object.

### get_record
This retrieves all detailed information for one specific record when you provide both the object key and the unique record ID.

### create_record
This tool adds a new entry into any Knack object. You must provide the data as a JSON string mapping field keys to values.

### update_record
The agent changes data in an existing record; you only send the fields and values that need changing.

### delete_record
Use this to permanently remove a record from a specific Knack object. Be careful, because this action cannot be undone.

### list_object_fields
This is essential for seeing all fields in a chosen object, including their data types and field keys needed for any write operation.

### search_records
This finds records using detailed filters. You supply the filter criteria as a JSON string for precise searching.

### list_account_applications
The agent runs this to list every application available within your connected Knack account.

## Prompt Examples

**Prompt:** 
```
List all database objects in my Knack app
```

**Response:** 
```
I've found 5 objects: 'Customers' (object_1), 'Orders' (object_2), 'Products' (object_3), 'Invoices' (object_4), and 'Settings' (object_5). Which one would you like to explore?
```

**Prompt:** 
```
Find all premium customers in 'object_1'
```

**Response:** 
```
Searching 'object_1' for records where 'Status' is 'Premium'… I've found 3 records: 'John Doe', 'Jane Smith', and 'Acme Corp'. Would you like to see the full details for any of these?
```

**Prompt:** 
```
Create a new customer in 'object_1' with name 'Sarah' and email 'sarah@example.com'
```

**Response:** 
```
Successfully created a new record in 'object_1'. Record ID: 65a4b3c2d1e0f. Field 1 (Name): Sarah, Field 2 (Email): sarah@example.com. Is there anything else you'd like to do with this record?
```

## Capabilities

### Discovering data structure
The MCP lists every object and field in your database so you know exactly what data is available.

### Adding new records
Your agent creates brand-new entries into any Knack object based on simple instructions.

### Retrieving specific records
You ask for a record by ID, and the MCP pulls back all its current details for auditing or review.

### Modifying existing data
The agent updates fields on an existing record; you only provide what needs changing.

### Searching with complex filters
You can search through records using multiple criteria, like finding all 'Premium' customers who live in 'California'.

### Mass data management
The MCP processes structured input to manage or update many records at once.

## Use Cases

### Auditing a customer profile
A manager needs to verify if 'Jane Smith' was assigned the correct tier status. Instead of digging through multiple tabs, they prompt: 'Get me the record for Jane Smith in object_1.' The agent uses `get_record` and provides all the necessary details immediately.

### Onboarding a new product line
A developer needs to confirm data types before writing code. They first call `list_objects` to find 'Products' (object_3), then use `list_object_fields` to verify that the 'SKU' field is text, ensuring their subsequent `create_record` command won't fail.

### Cleaning up old data
The ops team needs to remove all records marked as 'archived' older than a year. They use `search_records` with complex filters, confirm the results, and then authorize `delete_record` on that entire batch.

### Running an ad-hoc report
A data analyst needs to see all 'Gold' tier clients from a specific region. They prompt for this, and the agent uses `search_records` with geographical and status filters, delivering a targeted list of records.

## Benefits

- Stop jumping between dashboards. You can discover the full schema by calling `list_object_fields` and then use that knowledge to execute a specific update via `update_record`, all in one chat session.
- Need to audit data? Use `get_record` to pull up every detail for an entry instantly, or run `search_records` if you need to narrow the search by status or date range across many records.
- Managing multiple pieces of data is simple. You can use structured input with `create_record` to add new entries and then immediately follow up using `list_objects` to confirm the new object key was created correctly.
- It eliminates the manual steps of API testing. Instead of hitting endpoints one by one, you just tell your agent what needs doing—like running a bulk delete via `delete_record` on old data.
- When developing or managing operations, calling `list_objects` first is key. It provides the object keys you need to then run targeted queries like `list_records` against that specific collection.

## How It Works

The bottom line is, you connect once with your credentials, and your AI client gains immediate, conversational control over all your Knack data.

1. First, subscribe to the Knack MCP and provide your specific Knack Application ID and REST API Key.
2. Next, connect this MCP to any compatible AI client. The agent uses these credentials to establish a direct link to your no-code database.
3. Finally, start by asking simple questions like 'What objects do I have?' Your agent reads the schema and lets you manage data right in the chat.

## Frequently Asked Questions

**How do I find out what objects are in my Knack app using list_objects?**
Run the `list_objects` tool. It will return a list of all object keys available in your application, which is the first step to accessing any data.

**Can I update records with the update_record tool if I don't know the field names?**
No. Before using `update_record`, you must run `list_object_fields` on the object key to get a list of all valid, specific field keys for that data structure.

**What is the difference between list_records and search_records?**
`list_records` gives you every single record in an entire object. Use `search_records` when you need to filter those records by criteria, like 'status equals Active' or 'date greater than last month'.

**Is the create_record tool safe if I don't know all required fields?**
It's best practice to first run `list_object_fields` and confirm the object schema. This ensures you know exactly which keys are required before attempting to generate a new record.

**Does this MCP help me find out what other applications I have in Knack?**
Yes, running `list_account_applications` will list all the different applications or modules connected within your overall Knack account structure.

**When should I use the `list_object_fields` tool?**
You run this first to map out your data structure. It shows every field key and its required data type, which is essential before you try to run `create_record` or `update_record`. This prevents you from hitting schema errors.

**What information do I need to use the `get_record` tool?**
You must provide both the object key and the specific record ID. Running this tells you everything about one single entry, making it perfect for detailed data auditing or verifying a client's profile.

**Is using `delete_record` safe, and what are the risks?**
No, deleting records is irreversible. You must be absolutely certain of the object key and record ID before invoking this tool. Treat it like pulling the trigger: double-check your scope every time.

**How do I find the Object Key for a specific table?**
Use the `list_objects` tool. It will return all data objects in your application along with their names and unique keys (e.g., `object_1`). Use these keys for all subsequent record operations.

**Can I search records using multiple conditions?**
Yes. Use the `search_records` tool and provide a JSON array of filter objects. For example: `[{"field":"field_1", "operator":"is", "value":"active"}, {"field":"field_2", "operator":"contains", "value":"premium"}]`.

**How do I know which fields to use when creating a record?**
Use the `list_object_fields` tool with the target `object_key`. It will list all fields, their types, and their keys (e.g., `field_1`), which you must use as property names in your data JSON.