How to Connect Base44 to MCP Storage

According to the 2026 Developer Tooling Index, 78% of enterprise AI teams now use at least one Model Context Protocol (MCP) server in production to orchestrate agentic workflows [Developer Tooling Index 2026]. However, few of those teams have deployed centralized, audit-logged persistent storage to coordinate outputs between autonomous agents and human editors. This discrepancy highlights a major bottleneck in agentic software development. While vibe coding environments permit rapid application building through natural language instructions, moving these projects to production demands a persistent, secure data layer.

When developers build applications with tools like Base44, the generated code and database schemas often run in transient contexts. These sandboxed processes execute backend tasks, query entity databases, and update configurations, but they lack a permanent repository where their outputs are easily viewable by human collaborators. The standard developer workflow requires a mechanism to persist agent outputs, record detailed version histories, and coordinate files without relying on continuous polling. Connecting Base44 to a persistent, Model Context Protocol (MCP) storage workspace provides the necessary infrastructure to solve this problem.

By connecting these systems, AI developers establish a reliable workflow context where agents write documents, export dataset files, and submit deliverables directly to a shared workspace. Fastio acts as this persistent storage and collaboration layer, offering shared workspaces where human team members and AI tools interact. This guide explains how to establish this connection, detail the configuration parameters for the base44-mcp-server, and use Fastio's features to manage application assets.

Base44 is an AI-powered development environment designed to build, deploy, and manage full-stack web applications. By translating natural language prompts into working code, database entities, and serverless functions, the platform allows developers to create software systems. To make these systems accessible to external AI agents, the platform supports the Model Context Protocol.

Connecting Base44 to MCP storage allows local and hosted AI assistants to safely query entity schemas and data using the Model Context Protocol [Base44 Documentation]. This protocol solves the integration problem by providing a standardized interface between AI clients (such as Claude Desktop, Cursor, or Windsurf) and external backend tools. Instead of developing custom API integrations for every database table, the agent queries the platform's data models using a uniform set of tools.

The connection operates via two connection models: remote hosted access and local stdio execution. To support these connection models, the platform maintains one official hosted MCP server endpoint. This single hosted endpoint, located at app.base44.com/mcp, serves as the gateway for interacting with user projects. An official documentation server is also available at docs.base44.com/mcp, which allows AI assistants to query the platform's SDK references and development guides. Through these endpoints, an AI agent can execute operations including:

1. Creating new application projects based on natural language descriptions.

2. Editing existing application files and backend configurations.

3. Listing user projects and retrieving their metadata.

4. Querying database entity schemas and reading records from active collections.

This standardized access allows the agent to inspect the database structure, understand the relationships between different tables, and perform queries without manual configuration.

To connect your AI assistant to the platform, you must modify your client's configuration file. For example, when using Claude Desktop, this file is located at ~/Library/Application Support/Claude/claude_desktop_config.json on macOS or %APPDATA%\Claude\claude_desktop_config.json on Windows. This configuration block shows how to set up both the official account-linked endpoint and the unauthenticated documentation server:

{
  "mcpServers": {
    "base44": {
      "type": "http",
      "url": "https://app.base44.com/mcp"
    },
    "base44-docs": {
      "type": "http",
      "url": "https://docs.base44.com/mcp"
    }
  }
}

When you initialize Claude Desktop with this configuration, the client attempts to establish an HTTP connection to the specified URLs. Because the primary endpoint interacts with your personal projects, it requires authorization. The client will automatically open a system browser window, directing you to sign in to your developer account and grant permission for the agent to access your applications. Refer to the Fastio agents guide for more details on agent authentication.

For developers who prefer local execution or require faster response times, the server can be installed locally. This method involves cloning the official repository and running the server on your local machine. To set up the base44-mcp-server locally, run the following setup commands in your terminal:

git clone https://github.com/elirais/base44-mcp-server.git
cd base44-mcp-server
npm install

Once the dependencies are installed, configure your AI client to invoke the server using standard input/output (stdio) transport. In your configuration file, add the local server entry:

{
  "mcpServers": {
    "base44-local": {
      "command": "npx",
      "args": [
        "tsx",
        "/ABSOLUTE/PATH/TO/base44-mcp-server/src/stdio.ts"
      ]
    }
  }
}

Replace /ABSOLUTE/PATH/TO/ with the absolute path of the directory where you cloned the repository on your disk. This local configuration addresses a common documentation gap. Most guides overlook the specific CLI arguments required for setting up the server locally. The command must invoke npx, and the arguments array must specify tsx followed by the absolute path to the src/stdio.ts script. The tsx runner compiles and executes the TypeScript file on the fly, allowing the AI client to establish standard input/output communication with the server without requiring a separate pre-compilation step. For details on how agents use this file context, see the Fastio onboarding guidelines.

When selecting storage solutions for AI agents, developers often look at local directories, Amazon S3 buckets, or consumer cloud platforms like Google Drive. However, these options introduce challenges. Local disk storage is ephemeral, meaning files are lost when the agent sandbox restarts. Amazon S3 provides durable storage but lacks visual interface controls, making it difficult for human team members to inspect, edit, or sign off on files. Google Drive provides shared storage but its API requires complex authentication configurations and does not offer standard markdown note editing with live multiplayer cursors.

Fastio solves these issues by acting as the persistent storage and collaboration layer for agentic teams. Instead of isolating agents in private sandboxes, Fastio provides shared workspaces where humans and agents work together. When your Base44 backend app generates a report, invoice, or legal document, the system writes the file directly to a shared Fastio workspace using the Fastio MCP server. This connection keeps files durable, search-indexed, and instantly accessible to human review. For more information, visit the Fastio workspaces page.

Fastio provides several features to support this shared workspace workflow:

1. Shared Org-Owned Workspaces: Organizations own the files and workspaces, preventing data loss when individual agent sessions terminate or when developers change settings.

2. Per-File Version History: Every file in the workspace maintains a complete, restore-point version history. If an agent updates a file incorrectly or overwrites human changes, administrators can inspect the changes and restore previous versions. This version control ensures that concurrent agent access remains auditable.

3. Granular Permissions: Control access at the organization, workspace, folder, or file level. Developers can grant agents scoped access to specific folders while keeping sensitive files private.

4. Intelligence Mode: Once enabled on a workspace, Fastio's Intelligence Mode automatically indexes all uploaded files for semantic search, summarization, and citation-backed Q&A chat. The agent can query documents using natural language without needing a separate vector database.

5. Webhooks and Real-Time Events: Fastio broadcasts real-time events via WebSockets when files are uploaded, modified, or deleted. Your Base44 backend can listen to these webhooks to trigger automated workflows in response to file changes.

To start using these capabilities, teams can register an organization on one of Fastio's paid subscription plans. Fastio offers plans including Starter at $29/mo, Business at $99/mo, and Growth at $299/mo [Fastio Pricing]. Each organization starts with a fourteen-day free trial, which requires a credit card. The setup workflow supports agent handoff. The agent signs up, configures the initial workspaces, folders, and schemas, and then transfers ownership to a human administrator via a claim link. The human admin then creates the organization and adds a payment method to start the trial, ensuring the workspace remains active for the team. Read more on the Fastio agent storage details.

Connect Base44 to Persistent MCP Storage

Deploy a shared workspace with a consolidated MCP toolset, persistent file versioning, and automatic RAG indexing. Starts with a 14-day free trial.

Start 14-Day Trial

When agents interact with documents like PDF contracts, insurance policies, or invoices, they often need to extract specific fields. Traditional approaches rely on custom text-parsing scripts, strict OCR templates, or manual data entry. These setups are fragile, breaking whenever a vendor alters the document layout.

Fastio resolves this with Metadata Views, which turn documents into a queryable spreadsheet database. Unlike general search or summarization in Intelligence Mode, Metadata Views serve as the structured extraction layer for files. You can read more about this feature on the Metadata Views product page.

To set up a Metadata View, a developer describes the desired columns in natural language. For example, you can specify columns like 'Invoice Number', 'Total Amount', 'Vendor Name', and 'Due Date'. The AI engine analyzes the description, designs a typed schema using seven supported field types (Text, Integer, Decimal, Boolean, URL, JSON, and Date & Time), and automatically extracts the fields from all matching files in the workspace. Developers can add new columns at any time without reprocessing existing files.

A Base44 backend function can query these Metadata Views programmatically via the Fastio MCP server. Instead of downloading large files and parsing their content, the agent queries the view to retrieve structured JSON data. For example, if a Base44 application needs to audit invoices, the backend can query a Metadata View to identify all invoices where the total exceeds a specific threshold:

async function auditWorkspaceInvoices() {
  // Query the Metadata View via the Fastio MCP toolset
  const highValueInvoices = await fastio.queryMetadataView({
    viewId: "invoice-extraction-view",
    filter: "total > 5000"
  });
  for (const invoice of highValueInvoices) {
    console.log(`Processing high-value invoice from vendor: ${invoice.vendorName}`);
    // Trigger a billing approval function in Base44
    await base44.functions.invoke("processInvoiceApproval", {
      vendor: invoice.vendorName,
      total: invoice.total,
      dueDate: invoice.dueDate
    });
  }
}

This program queries the view directly, receiving structured fields that are pre-validated by the schema. This integration avoids text-parsing errors, speeds up processing, and allows developers to build complex automation loops around document data. Learn about pricing for these storage tools on our pricing details page.

Setting up local and remote integrations can occasionally result in connection failures. When working with the local configuration for the base44-mcp-server, the most common issue is a stdio path resolution error. If your AI assistant displays an error indicating that the server failed to start, verify the absolute path specified in your JSON configuration. The path to the src/stdio.ts file must be absolute and use forward slashes, even on Windows systems when using specific clients. Also ensure that Nodejs (version twenty or higher) is installed on your local machine and that the command npx is available in your system path.

If the path is correct but the server still fails to launch, check the dependencies within the cloned repository. Run npm install inside the base44-mcp-server directory to verify that packages like tsx are correctly installed. If the server terminates with an import error, it indicates that the runtime is failing to locate the necessary modules. You can test if the server runs successfully from your terminal by running:

npx tsx /ABSOLUTE/PATH/TO/base44-mcp-server/src/stdio.ts

The process should start without throwing an error and wait for input on standard input. If it exits immediately with a status code, review the console error messages to diagnose the underlying runtime issue.

When using the remote hosted endpoint (app.base44.com/mcp), connection issues are typically related to OAuth authorization loops. If your AI assistant continuously requests authentication, clear the browser cache and cookies for the platform's domain, then restart the authorization process. Ensure that the client is not blocked by pop-up blockers or security software that prevents external browser redirections. Once authorized, the server will issue a scoped token that is stored by the client, allowing the agent to query application schemas and entities without requiring manual sign-ins.