Skip to main content
Glama
LawrenceCirillo

QuickBase MCP Server

quickbase_bulk_create_records

Add multiple records to a specific table in QuickBase using this MCP server tool, streamlining bulk data entry for efficient database management.

Instructions

Create multiple records at once

Input Schema

TableJSON Schema
NameRequiredDescriptionDefault
recordsYesArray of records to create
tableIdYesTable ID

Implementation Reference

  • Core handler function that implements bulk record creation by POSTing an array of records to QuickBase API /records endpoint and extracting the new record IDs.
    async createRecords(tableId: string, records: QuickBaseRecord[]): Promise<number[]> {
      const response = await this.axios.post('/records', {
        to: tableId,
        data: records.map(record => record.fields)
      });
      return response.data.data.map((record: any) => record['3'].value);
    }
  • MCP server switch case handler that validates input arguments and delegates to QuickBaseClient.createRecords, returning success message with created record IDs.
    case 'quickbase_bulk_create_records':
      if (!args || typeof args !== 'object') {
        throw new Error('Invalid arguments');
      }
      const recordIds = await this.qbClient.createRecords(
        args.tableId as string, 
        args.records as any[]
      );
      return {
        content: [
          {
            type: 'text',
            text: `Created ${recordIds.length} records: ${recordIds.join(', ')}`,
          },
        ],
      };
  • Tool definition including name, description, and input schema for validating parameters: tableId and array of records with fields.
    {
      name: 'quickbase_bulk_create_records',
      description: 'Create multiple records at once',
      inputSchema: {
        type: 'object',
        properties: {
          tableId: { type: 'string', description: 'Table ID' },
          records: {
            type: 'array',
            items: {
              type: 'object',
              properties: {
                fields: { type: 'object', additionalProperties: true }
              }
            },
            description: 'Array of records to create'
          }
        },
        required: ['tableId', 'records']
      }
    },
  • Exports the array of all QuickBase tools including quickbase_bulk_create_records, used by MCP server for listing available tools.
    export const quickbaseTools: Tool[] = [
      // ========== APPLICATION TOOLS ==========
      {
        name: 'quickbase_get_app_info',
        description: 'Get information about the QuickBase application',
        inputSchema: {
          type: 'object',
          properties: {},
          required: []
        }
      },
    
      {
        name: 'quickbase_get_tables',
        description: 'Get list of all tables in the application',
        inputSchema: {
          type: 'object',
          properties: {},
          required: []
        }
      },
    
      {
        name: 'quickbase_test_connection',
        description: 'Test connection to QuickBase',
        inputSchema: {
          type: 'object',
          properties: {},
          required: []
        }
      },
    
      // ========== TABLE TOOLS ==========
      {
        name: 'quickbase_create_table',
        description: 'Create a new table in QuickBase',
        inputSchema: {
          type: 'object',
          properties: {
            name: { type: 'string', description: 'Table name' },
            description: { type: 'string', description: 'Table description' }
          },
          required: ['name']
        }
      },
    
      {
        name: 'quickbase_get_table_info',
        description: 'Get detailed information about a specific table',
        inputSchema: {
          type: 'object',
          properties: {
            tableId: { type: 'string', description: 'QuickBase table ID' }
          },
          required: ['tableId']
        }
      },
    
      {
        name: 'quickbase_delete_table',
        description: 'Delete a table from QuickBase',
        inputSchema: {
          type: 'object',
          properties: {
            tableId: { type: 'string', description: 'QuickBase table ID to delete' }
          },
          required: ['tableId']
        }
      },
    
      // ========== FIELD TOOLS ==========
      {
        name: 'quickbase_get_table_fields',
        description: 'Get all fields for a table',
        inputSchema: {
          type: 'object',
          properties: {
            tableId: { type: 'string', description: 'QuickBase table ID' }
          },
          required: ['tableId']
        }
      },
    
      {
        name: 'quickbase_create_field',
        description: 'Create a new field in a table',
        inputSchema: {
          type: 'object',
          properties: {
            tableId: { type: 'string', description: 'Table ID to add field to' },
            label: { type: 'string', description: 'Field label/name' },
            fieldType: { 
              type: 'string',
              enum: ['text', 'text_choice', 'text_multiline', 'richtext', 'numeric', 'currency', 'percent', 'date', 'datetime', 'checkbox', 'email', 'phone', 'url', 'address', 'file', 'lookup', 'formula', 'reference'],
              description: 'Type of field'
            },
            required: { type: 'boolean', description: 'Whether field is required', default: false },
            unique: { type: 'boolean', description: 'Whether field must be unique', default: false },
            choices: { type: 'array', items: { type: 'string' }, description: 'Choices for choice fields' },
            formula: { type: 'string', description: 'Formula for formula fields' },
            lookupTableId: { type: 'string', description: 'Table ID for lookup fields' },
            lookupFieldId: { type: 'number', description: 'Field ID for lookup fields' }
          },
          required: ['tableId', 'label', 'fieldType']
        }
      },
    
      {
        name: 'quickbase_update_field',
        description: 'Update an existing field',
        inputSchema: {
          type: 'object',
          properties: {
            tableId: { type: 'string', description: 'Table ID' },
            fieldId: { type: 'number', description: 'Field ID to update' },
            label: { type: 'string', description: 'New field label' },
            required: { type: 'boolean', description: 'Whether field is required' },
            choices: { type: 'array', items: { type: 'string' }, description: 'New choices for choice fields' }
          },
          required: ['tableId', 'fieldId']
        }
      },
    
      {
        name: 'quickbase_delete_field',
        description: 'Delete a field from a table',
        inputSchema: {
          type: 'object',
          properties: {
            tableId: { type: 'string', description: 'Table ID' },
            fieldId: { type: 'number', description: 'Field ID to delete' }
          },
          required: ['tableId', 'fieldId']
        }
      },
    
      // ========== RECORD TOOLS ==========
      {
        name: 'quickbase_query_records',
        description: 'Query records from a table with optional filtering and sorting',
        inputSchema: {
          type: 'object',
          properties: {
            tableId: { type: 'string', description: 'Table ID to query' },
            select: { type: 'array', items: { type: 'number' }, description: 'Field IDs to select' },
            where: { type: 'string', description: 'QuickBase query filter (e.g., "{6.EX.\'John\'}")' },
            sortBy: { 
              type: 'array', 
              items: {
                type: 'object',
                properties: {
                  fieldId: { type: 'number' },
                  order: { type: 'string', enum: ['ASC', 'DESC'] }
                }
              },
              description: 'Sort criteria'
            },
            top: { type: 'number', description: 'Max number of records' },
            skip: { type: 'number', description: 'Number of records to skip' }
          },
          required: ['tableId']
        }
      },
    
      {
        name: 'quickbase_get_record',
        description: 'Get a specific record by ID',
        inputSchema: {
          type: 'object',
          properties: {
            tableId: { type: 'string', description: 'Table ID' },
            recordId: { type: 'number', description: 'Record ID' },
            fieldIds: { type: 'array', items: { type: 'number' }, description: 'Specific field IDs to retrieve' }
          },
          required: ['tableId', 'recordId']
        }
      },
    
      {
        name: 'quickbase_create_record',
        description: 'Create a new record in a table',
        inputSchema: {
          type: 'object',
          properties: {
            tableId: { type: 'string', description: 'Table ID to create record in' },
            fields: { 
              type: 'object', 
              description: 'Field values as fieldId: {value: actualValue} pairs',
              additionalProperties: true
            }
          },
          required: ['tableId', 'fields']
        }
      },
    
      {
        name: 'quickbase_update_record',
        description: 'Update an existing record',
        inputSchema: {
          type: 'object',
          properties: {
            tableId: { type: 'string', description: 'Table ID' },
            recordId: { type: 'number', description: 'Record ID to update' },
            fields: { 
              type: 'object', 
              description: 'Field values to update as fieldId: {value: actualValue} pairs',
              additionalProperties: true
            }
          },
          required: ['tableId', 'recordId', 'fields']
        }
      },
    
      {
        name: 'quickbase_delete_record',
        description: 'Delete a record from a table',
        inputSchema: {
          type: 'object',
          properties: {
            tableId: { type: 'string', description: 'Table ID' },
            recordId: { type: 'number', description: 'Record ID to delete' }
          },
          required: ['tableId', 'recordId']
        }
      },
    
      {
        name: 'quickbase_bulk_create_records',
        description: 'Create multiple records at once',
        inputSchema: {
          type: 'object',
          properties: {
            tableId: { type: 'string', description: 'Table ID' },
            records: {
              type: 'array',
              items: {
                type: 'object',
                properties: {
                  fields: { type: 'object', additionalProperties: true }
                }
              },
              description: 'Array of records to create'
            }
          },
          required: ['tableId', 'records']
        }
      },
    
      {
        name: 'quickbase_search_records',
        description: 'Search for records containing specific text',
        inputSchema: {
          type: 'object',
          properties: {
            tableId: { type: 'string', description: 'Table ID to search' },
            searchTerm: { type: 'string', description: 'Text to search for' },
            fieldIds: { type: 'array', items: { type: 'number' }, description: 'Field IDs to search in' }
          },
          required: ['tableId', 'searchTerm']
        }
      },
    
      // ========== RELATIONSHIP TOOLS ==========
      {
        name: 'quickbase_create_relationship',
        description: 'Create a parent-child relationship between tables',
        inputSchema: {
          type: 'object',
          properties: {
            parentTableId: { type: 'string', description: 'Parent table ID' },
            childTableId: { type: 'string', description: 'Child table ID' },
            foreignKeyFieldId: { type: 'number', description: 'Foreign key field ID in child table' }
          },
          required: ['parentTableId', 'childTableId', 'foreignKeyFieldId']
        }
      },
    
      {
        name: 'quickbase_get_relationships',
        description: 'Get relationships for a table',
        inputSchema: {
          type: 'object',
          properties: {
            tableId: { type: 'string', description: 'Table ID' }
          },
          required: ['tableId']
        }
      },
    
      // ========== UTILITY TOOLS ==========
      {
        name: 'quickbase_get_reports',
        description: 'Get all reports for a table',
        inputSchema: {
          type: 'object',
          properties: {
            tableId: { type: 'string', description: 'Table ID' }
          },
          required: ['tableId']
        }
      },
    
      {
        name: 'quickbase_run_report',
        description: 'Run a specific report',
        inputSchema: {
          type: 'object',
          properties: {
            reportId: { type: 'string', description: 'Report ID' },
            tableId: { type: 'string', description: 'Table ID' }
          },
          required: ['reportId', 'tableId']
        }
      },
    
      // ========== ENHANCED RELATIONSHIP TOOLS ==========
      {
        name: 'quickbase_create_advanced_relationship',
        description: 'Create a comprehensive table relationship with automatic lookup fields',
        inputSchema: {
          type: 'object',
          properties: {
            parentTableId: { type: 'string', description: 'Parent table ID' },
            childTableId: { type: 'string', description: 'Child table ID' },
            referenceFieldLabel: { type: 'string', description: 'Label for the reference field to create' },
            lookupFields: {
              type: 'array',
              items: {
                type: 'object',
                properties: {
                  parentFieldId: { type: 'number', description: 'Field ID in parent table to lookup' },
                  childFieldLabel: { type: 'string', description: 'Label for lookup field in child table' }
                },
                required: ['parentFieldId', 'childFieldLabel']
              },
              description: 'Lookup fields to create automatically'
            },
            relationshipType: { 
              type: 'string', 
              enum: ['one-to-many', 'many-to-many'], 
              default: 'one-to-many',
              description: 'Type of relationship' 
            }
          },
          required: ['parentTableId', 'childTableId', 'referenceFieldLabel']
        }
      },
    
      {
        name: 'quickbase_create_lookup_field',
        description: 'Create a lookup field to pull data from a related table',
        inputSchema: {
          type: 'object',
          properties: {
            childTableId: { type: 'string', description: 'Child table ID where lookup field will be created' },
            parentTableId: { type: 'string', description: 'Parent table ID to lookup from' },
            referenceFieldId: { type: 'number', description: 'Reference field ID in child table' },
            parentFieldId: { type: 'number', description: 'Field ID in parent table to lookup' },
            lookupFieldLabel: { type: 'string', description: 'Label for the new lookup field' }
          },
          required: ['childTableId', 'parentTableId', 'referenceFieldId', 'parentFieldId', 'lookupFieldLabel']
        }
      },
    
      {
        name: 'quickbase_validate_relationship',
        description: 'Validate the integrity of a table relationship',
        inputSchema: {
          type: 'object',
          properties: {
            parentTableId: { type: 'string', description: 'Parent table ID' },
            childTableId: { type: 'string', description: 'Child table ID' },
            foreignKeyFieldId: { type: 'number', description: 'Foreign key field ID to validate' }
          },
          required: ['parentTableId', 'childTableId', 'foreignKeyFieldId']
        }
      },
    
      {
        name: 'quickbase_get_relationship_details',
        description: 'Get detailed information about table relationships including lookup fields',
        inputSchema: {
          type: 'object',
          properties: {
            tableId: { type: 'string', description: 'Table ID to analyze relationships for' },
            includeFields: { type: 'boolean', default: true, description: 'Include related field details' }
          },
          required: ['tableId']
        }
      },
    
      {
        name: 'quickbase_create_junction_table',
        description: 'Create a junction table for many-to-many relationships',
        inputSchema: {
          type: 'object',
          properties: {
            junctionTableName: { type: 'string', description: 'Name for the junction table' },
            table1Id: { type: 'string', description: 'First table ID' },
            table2Id: { type: 'string', description: 'Second table ID' },
            table1FieldLabel: { type: 'string', description: 'Label for reference to first table' },
            table2FieldLabel: { type: 'string', description: 'Label for reference to second table' },
            additionalFields: {
              type: 'array',
              items: {
                type: 'object',
                properties: {
                  label: { type: 'string' },
                  fieldType: { type: 'string' }
                }
              },
              description: 'Additional fields for the junction table'
            }
          },
          required: ['junctionTableName', 'table1Id', 'table2Id', 'table1FieldLabel', 'table2FieldLabel']
        }
      },
    ];
Behavior2/5

Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?

With no annotations provided, the description carries full burden for behavioral disclosure. It states 'create' implies a write/mutation operation but lacks details on permissions required, rate limits, error handling (e.g., partial failures), or response format. For a bulk write tool with zero annotation coverage, this is a significant gap in transparency.

Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.

Conciseness5/5

Is the description appropriately sized, front-loaded, and free of redundancy?

The description is a single, efficient sentence ('Create multiple records at once') that is front-loaded with the core purpose. It wastes no words and is appropriately sized for a tool with clear parameters and sibling context, though it could benefit from additional context.

Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.

Completeness2/5

Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?

Given the complexity of a bulk write operation, no annotations, and no output schema, the description is incomplete. It lacks details on behavioral aspects (e.g., atomicity, error handling), usage guidelines, and output expectations. For a tool with 2 required parameters and mutation intent, more context is needed to be fully helpful.

Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.

Parameters3/5

Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?

Schema description coverage is 100%, with clear descriptions for 'tableId' and 'records'. The description adds no parameter-specific semantics beyond implying bulk creation (aligning with 'records' as an array). Since the schema already documents parameters well, the baseline score of 3 is appropriate, as the description doesn't enhance parameter understanding.

Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.

Purpose4/5

Does the description clearly state what the tool does and how it differs from similar tools?

The description 'Create multiple records at once' clearly states the verb ('create') and resource ('records'), with the qualifier 'multiple...at once' indicating bulk operation. It distinguishes from sibling 'quickbase_create_record' by specifying bulk capability, though it doesn't explicitly mention the table context or differentiate from other creation tools like 'quickbase_create_table'.

Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.

Usage Guidelines2/5

Does the description explain when to use this tool, when not to, or what alternatives exist?

The description provides no guidance on when to use this tool versus alternatives. It doesn't mention when bulk creation is preferred over single-record creation ('quickbase_create_record'), prerequisites like table existence, or exclusions (e.g., vs. 'quickbase_create_table' for table-level operations). Usage is implied by 'multiple records' but lacks explicit context.

Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.

Install Server

Other Tools

Related Tools

Latest Blog Posts

MCP directory API

We provide all the information about MCP servers via our MCP API.

curl -X GET 'https://glama.ai/api/mcp/v1/servers/LawrenceCirillo/QuickBase-MCP-Server'

If you have feedback or need assistance with the MCP directory API, please join our Discord server