Skip to main content
Glama
LawrenceCirillo

QuickBase MCP Server

quickbase_get_app_info

Retrieve detailed information about a QuickBase application using the Model Context Protocol server. This tool enables users to access and manage application data efficiently within the QuickBase MCP Server framework.

Instructions

Get information about the QuickBase application

Input Schema

TableJSON Schema
NameRequiredDescriptionDefault

No arguments

Implementation Reference

  • Core handler function that executes the QuickBase API call to retrieve application information.
    async getAppInfo(): Promise<any> {
      const response = await this.axios.get(`/apps/${this.config.appId}`);
      return response.data;
    }
  • MCP server tool dispatch handler that calls QuickBaseClient.getAppInfo() and formats the response.
    case 'quickbase_get_app_info':
      return {
        content: [
          {
            type: 'text',
            text: JSON.stringify(await this.qbClient.getAppInfo(), null, 2),
          },
        ],
      };
  • Tool schema definition with empty input parameters and description.
      name: 'quickbase_get_app_info',
      description: 'Get information about the QuickBase application',
      inputSchema: {
        type: 'object',
        properties: {},
        required: []
      }
    },
  • Registration of all QuickBase tools array exported for MCP server use.
    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?

No annotations are provided, so the description carries full burden for behavioral disclosure. It states this is a 'Get' operation, implying read-only behavior, but doesn't specify what information is returned, authentication requirements, rate limits, or error conditions. For a tool with zero annotation coverage, this leaves significant behavioral gaps.

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 with zero wasted words. It's appropriately sized for a simple, parameterless tool and front-loads the essential purpose without unnecessary elaboration.

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 lack of annotations and output schema, the description is insufficiently complete. It doesn't explain what 'application information' includes (e.g., metadata, settings, statistics) or the return format. For a tool in a rich ecosystem with many sibling alternatives, more context is needed to understand its specific role.

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

Parameters4/5

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

The tool has 0 parameters with 100% schema description coverage, so the baseline is 4. The description doesn't need to compensate for any parameter documentation gaps, and it correctly implies no inputs are required for this operation.

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

Purpose3/5

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

The description states the tool's purpose ('Get information about the QuickBase application'), which is clear but vague. It specifies the verb ('Get') and resource ('QuickBase application'), but doesn't distinguish it from sibling tools like 'quickbase_get_table_info' or 'quickbase_get_relationships', which also retrieve information about specific application components.

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. With sibling tools like 'quickbase_get_table_info' and 'quickbase_get_tables' that retrieve specific application data, there's no indication of what 'application information' includes or when this general tool is preferred over more specific ones.

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