Skip to main content

Frequently Asked Questions

This page compiles frequently asked questions about integration development. If your question is not listed here, you can find support channels at the bottom of this page.

AI-Assisted Development​

How Can AI Help Me Write Code?​

AI can help you write code, but it is not as simple as "just type a prompt in Claude Code." Try it: without backend APIs, AI generates nothing but const mockData = [...]. You have to build the backend first: choose a framework, connect to a database, write CRUD APIs, handle authentication, configure CORS. The backend takes a week, while the frontend just waits. Integration testing takes another week: field names don't match (the backend calls it customer_name, the frontend writes name), parameter formats don't match (the backend expects page/size, the frontend sends currentPage/pageSize), response structures don't match (the backend wraps { data: {...} }, the frontend reads from the top level). SQL JOIN conditions are pure guesswork -- field names are correct 3 out of 10 times. A single list page takes at least two weeks of frontend-backend integration. The rabetbase trio eliminates backend setup and integration entirely: BaaS's database reverse-engineering engine automatically extracts business models, with APIs, SDKs, and enterprise-grade permissions all ready -- no backend setup, no API writing; CLI provides system-level tools -- inspect structures, generate SDKs, save SQL, sync menus, all with a single command; Skill guides AI to follow SOPs -- field names are correct, API call patterns are correct, SQL JOIN conditions are correct. Together, the trio completes in 10 minutes what traditionally takes 2 weeks.

After installing the Rabetbase Skill, describe your requirements in natural language in Claude Code or Cursor, and remember to mention "use rabetbase CLI":

Use rabetbase CLI to help me create a customer list page with search and pagination, reading data from the customer dataset.

AI will automatically use the rabetbase CLI to query dataset structures, generate code, create custom SQL, and more.

What Is the Difference Between Skill and Writing Code Directly?​

AspectWriting Code DirectlyAI + Skill
Data ExplorationManual documentation lookup, 20-30 minutesAI completes it in seconds
Code GenerationHand-written + repeated debuggingAI generates in one pass, 95%+ accuracy
SQL DesignRepeated debugging, 30-60 minutesAI completes in 1-2 minutes
Complete Page2-3 hours10-15 minutes

Which AI Tools Does Skill Support?​

Integration development uses a micro-frontend architecture. Your code lives in an independent repository, completely isolated from the main system.

AspectIntegration Development (Micro-frontend)Modifying the Main System Directly
Code IsolationIndependent repository, clear boundariesMixed into the main system code
Maintenance CostLow -- only maintain your own codeHigh -- conflicts when the main system updates
Team CollaborationDifferent teams develop independentlyProne to interfering with each other
Deployment FlexibilityIndependent build and deploymentMust redeploy the entire system
Version ControlIndependent versioningCoupled with the main system version

We recommend using integration development and integrating with the main system via rabetbase menu sync with a single command.

Is MCP Configuration Required?​

No, but it is strongly recommended.

With MCP configured, AI can fully understand your data structures, generating code with near-100% accuracy and cutting development time by more than half. Without it, you can still use the SDK to write code manually -- you will just need to look up documentation and understand APIs yourself, which is less efficient.

In short: it works without it, but with it you get twice the result with half the effort.

Which AI Tools Does MCP Support?​

Currently, all AI tools compatible with the Skill protocol are supported, including Claude Code, Cursor, and others. Installation is simple:

npx skills add lovrabet/rabetbase --global

Will the Main System Show New Pages Immediately After Menu Sync?​

Yes. Once rabetbase menu sync completes, the menu appears immediately in the main system. When users click it, your sub-application page loads. Users will not notice that it was developed as an independent sub-application.

If the menu does not appear, check the following:

  1. Did rabetbase menu sync execute successfully?
  2. Has the sub-application been deployed to the server?
  3. Is the main application's sub-application configuration correct?
  4. Try refreshing the main system page.

How to Debug Failed SDK Calls?​

The SDK provides a debug mode. When enabled, it outputs complete request and response information to the console:

const client = createClient({
  appCode: "your-app-code",
  accessKey: process.env.ACCESS_KEY,
  options: {
    debug: true,
  },
});

Common errors and solutions:

ErrorCauseSolution
401 UnauthorizedAuthentication failedCheck AccessKey or Token
403 ForbiddenInsufficient permissionsCheck dataset access permissions
404 Not FoundResource does not existCheck if datasetCode is correct
400 Bad RequestInvalid parametersCheck request parameter format
Network ErrorNetwork or CORS issueCheck network connection and CORS configuration
Token ExpiredToken has expiredRegenerate Token or use Cookie

More debugging tips: SDK Troubleshooting

Can One Application Have Multiple Sub-applications?​

Yes, this is exactly the advantage of the micro-frontend architecture.

For example, Team A develops a "Sales Analysis" extension, Team B develops a "Customer Service" extension, and Team C develops a "Financial Reports" extension -- each with its own independent repository and deployment. All are synced to the main system via rabetbase menu sync, appearing to users as a single cohesive application.

Things to note:

  • Ensure menu names are unique across different sub-applications
  • Recommend standardizing SDK and CLI versions
  • Shared component libraries can be used

Will Sub-application Performance Be Affected?​

No. Under the micro-frontend architecture, sub-applications are loaded on demand -- only when a user visits a page is the corresponding code loaded. Combined with independent caching and the CLI's built-in build optimizations, performance is not a concern.

In day-to-day development, just keep these points in mind:

// Route lazy loading
const CustomerAnalysis = lazy(() => import("./pages/CustomerAnalysis"));

// Import on demand, not the entire package
import debounce from "lodash-es/debounce"; // Good
// import _ from "lodash";  // Bad

// Paginate data, don't fetch everything at once
const result = await client.models.customers.filter({
  currentPage: 1,
  pageSize: 20,
});

Will Skill Leak Data?​

No. Rabetbase Skill runs locally on your machine and only reads metadata from datasets (table structures, field definitions) -- it never reads actual business data. What AI understands through Skill is "what tables you have and what fields each table contains," not "what Zhang San's phone number is."

The information MCP passes looks roughly like this:

{
  tableName: "customers",
  fields: [
    { name: "id", type: "string", isPrimaryKey: true },
    { name: "customer_name", type: "string" },
    { name: "phone", type: "string" },
    { name: "company", type: "string" }
  ]
}

How to Preview Results During Local Development?​

During local development, your sub-application runs independently:

rabetbase run start
# Sub-application runs at http://localhost:3000
# Data is fetched from the real system via SDK

If you need to see the full effect after integration with the main system, there are two approaches:

  1. Option 1: Configure your local address as the sub-application entry point in the test environment
  2. Option 2: Build and deploy to the test server, then sync the menu

For day-to-day development, we recommend using local mode for rapid iteration, and periodically deploying to the test environment to verify integration results.

Can Sub-applications Access All Data in the Main System?​

Sub-applications access data via the SDK, and permissions are determined by the authentication method:

  • Cookie Authentication: Inherits the permissions of the currently logged-in user
  • AccessKey Authentication: Inherits the permissions configured for the AccessKey

Dataset and field-level permissions are subject to the platform's permission system.

Security recommendations:

  • Use AccessKey on the server side, and Token or Cookie in the browser
  • Follow the principle of least privilege
  • Never hardcode AccessKey in frontend code

Important Notes​

Security​

  • Never hardcode AccessKey in frontend code
  • Use environment variables to manage sensitive information
  • Use Token or Cookie authentication in production environments
  • Use HTTPS for data transmission
  • Regularly update SDK and CLI versions

Version Compatibility​

  • Ensure SDK, CLI, and Skill versions are compatible
  • Keep an eye on toolchain changelogs
  • Verify in the test environment before deploying to production

Recommended version management approach:

{
  "dependencies": {
    "@lovrabet/sdk": "^1.1.18",
    "@lovrabet/rabetbase-cli": "^2.0.0"
  }
}
  • Use Title annotations to provide clear display names
  • Avoid special characters
  • Ensure menu names are unique within the application
  • Keep names concise and clear, no more than 10 characters

Good examples: Customer Analysis, Sales Funnel, Data Report

Bad examples: page1, Customer Behavior Analysis and Prediction System Based on Machine Learning Algorithms

Documentation​

Packages​

Example Projects​

Technical Support​