KoniKode · Software built with intention

DOCUMENTATION FOR YOUR TOOLS

Full reference.
Account-controlled access.

Connect your development tools to product guidance and the complete selected Clean Framework reference. Use your shared KoniKode account to create a read-only key, then retrieve only the context your task needs.

111 catalog records79 full framework documentsRead-only keysAccount rate limits

One account. The complete reference.

The account-linked Knowledge API is available at https://konikode.com. Create a free KoniKode account, verify your email and issue a read-only key. The API includes 32 product guides and all 79 approved Clean Framework documents.

The browser Knowledge Base stays open without an account. Machine API credentials do not grant source-code licenses, paid subscriptions, staff access or rights to independent product accounts.

START WITH YOUR KONIKODE ACCOUNT

One identity. A key for each tool.

  1. Create or sign in to the shared account

    Use account registration, verify your email and sign in. Verification and recovery emails use your account email address. Check your inbox for the one-time code; verification asks you to choose your password and confirm the current terms.

  2. Create a read-only credential

    Open My Account → API access. Choose a label and confirm your current password and second factor if enabled. Save the key immediately: the complete value is shown once. Five active keys are allowed; each expires after 90 days.

  3. Configure the host’s secret storage

    Send the key in X-KoniKode-API-Key, never in a URL or tool argument. Keep credentials out of source control, screenshots, browser bundles and logs. A browser application should call its own authorized server integration rather than embed a long-lived machine key.

Revoking a key takes effect on new requests. Account suspension, password recovery, password changes and security-version changes invalidate existing credentials. Already accepted requests may finish. No paid subscription or per-product grant is required for this read-only documentation scope.

MAKE YOUR FIRST REQUEST

Discover, search, retrieve.

Have your host secret store supply curl configuration through standard input, including the API-key header. Keep the key in an owner-only credential file or your tool’s secret store; do not paste it into a command, repository or chat.

1. Discover documents for a product

Read the total and returned IDs. Select a relevant result before fetching more context.

curl --config - --fail-with-body --max-time 10 \
  --header 'Accept: application/json' \
  'https://konikode.com/api/knowledge?product=clean-framework&collection=reference&limit=5'

2. Search within that product

Search titles, product names, summaries, paragraphs and key points. This is text matching, so an empty result is valid.

curl --config - --fail-with-body --max-time 10 \
  --header 'Accept: application/json' \
  'https://konikode.com/api/knowledge?product=clean-framework&collection=reference&q=application&limit=5'

3. Retrieve a document by its ID

Read the document and retain its ID, title, content version and links with your integration notes.

curl --config - --fail-with-body --max-time 10 \
  --header 'Accept: application/json' \
  'https://konikode.com/api/knowledge/clean-framework-reference-new-application'

Metadata first, complete text on demand

List/search results contain version, total, limit, offset and documents. Lists contain metadata, without multiplying full Markdown across every result.

GET by a returned reference ID supplies document.markdown, sha256, category, reader_url and the existing core fields. All 79 imported documents are available. Reference IDs begin clean-framework-reference-; existing product-guide IDs stay unchanged.

Retain the source and version

The response contract is version 1; the managed OpenAPI description is 1.1.0. An imported document’s content version is its complete SHA-256 digest. Verify it against the exact UTF-8 Markdown and cite its reader link. Framework release versions are separate.

Unknown products or unmatched searches return HTTP 200 with an empty list. Unknown IDs return 404. Read the candidate boundary before treating documentation as a supported production release.

GET /api/knowledge query parameters
ParameterUseLimit
productExact product slug; omit for all products.64 bytes; e.g. clean-framework.
collectionSelect product records or full references.all (default), product, reference.
qCase-insensitive search, including full reference Markdown.100 UTF-8 bytes.
limitMetadata records per page.1–50; default 20.
offsetRecords to skip in publication order.0–99999; default 0.

Use scalar values and ordinary decimal integers. Leading-zero pagination and structured parameters are rejected. Add limit to offset for another page; stop at total or an empty page. There is no transactional snapshot token: bound pagination and detect changing totals or duplicate IDs.

PREDICTABLE LIMITS AND RECOVERY

Pause when the service asks.

Shared account budgets

All keys on an account share 60 requests per minute and 1,000 per hour. Additional safeguards allow 120 per minute per IP and 600 per minute across the API. Schema and preflight requests count toward the IP/global budgets.

Limits are atomically enforced on the server before document work. Errors and invalid authenticated requests consume capacity too. These are initial service safeguards, not purchased usage tiers or protection against every network-level denial-of-service attack.

Handle each failure deliberately

JSON errors contain success: false, code and message. HTTP 400 means invalid input; 401 means missing/invalid credentials; 404 means unavailable content; 405 means unsupported method; 429 means pause for Retry-After seconds. Storage failure returns 503 and fails closed.

Set a deadline and response-size limit. Avoid automatic retry loops; never retry invalid input or a revoked credential repeatedly. Show useful recovery, cancellation or retry controls in your application.

GET, HEAD and OPTIONS are supported. API responses allow cross-origin reads using the explicit key header, without browser cookies or credentialed CORS. No browser session cookie is needed for machine API access. CORS does not apply this API policy to account or reader pages.

Cache-Control: private, no-store applies to responses and errors. API results, account pages and keys stay outside PWA caches. Rate limits cover this API; the intentionally open browser reader is a separate surface.

CLI, MCP AND FRONTBASEJS

Use the existing integration foundations.

The authorized website checkout contains a Node.js 22+ client and stdio MCP adapter. Its owner-only JSON credential file supplies origin, apiKey for https://konikode.com. The credential file is read in memory only. Set KONIKODE_KNOWLEDGE_CREDENTIALS_FILE to its path. Tools never accept credentials from model arguments or return them in results.

Use the Node CLI from an authorized checkout
# Set this path in your host environment; the file itself is owner-only (0600).
export KONIKODE_KNOWLEDGE_CREDENTIALS_FILE=/private/path/knowledge.json
node tools/knowledge/cli.mjs list --product clean-framework --collection reference --all
node tools/knowledge/cli.mjs search "application" --product clean-framework --collection reference
node tools/knowledge/cli.mjs get clean-framework-reference-new-application

--all retrieves bounded metadata, not every full document body. Fetch the returned IDs you need. The client verifies reference hashes and adds source links. It does not cache responses or retry automatically.

Connect the existing stdio MCP adapter
{
  "command": "/absolute/path/to/node",
  "args": [
    "/absolute/path/to/authorized-checkout/tools/knowledge/mcp.mjs",
    "https://konikode.com"
  ],
  "env": { "KONIKODE_KNOWLEDGE_CREDENTIALS_FILE": "/private/path/knowledge.json" }
}

Pass the credential-file path through the host’s environment configuration. knowledge_search and knowledge_list accept collection: "reference" and up to 20 results per page; knowledge_get returns complete selected Markdown and its citation.

This launch entry does not install an IDE extension or register a host automatically. Public framework/SDK distribution and support remain release work.

This FrontBaseJS example runs in a Node server/IDE context with authorized source and a build resolving @frontbase/http. It uses the actual pinned HTTP contract. Do not ship its credential-loading code into a browser.

// Node server/IDE context with authorized source; never bundle credentials for a browser.
import { HttpClient } from '@frontbase/http';
import { loadKnowledgeCredentials } from './tools/knowledge/credentials.mjs';

const settings = loadKnowledgeCredentials();
if (!settings) throw new Error('Configure the private Knowledge credential file.');
const knowledge = new HttpClient({
  baseUrl: settings.origin,
  timeoutMilliseconds: 8000,
  maximumResponseBytes: 1048576,
  retryCount: 0
});
const page = await knowledge.get(
  '/api/knowledge?product=clean-framework&collection=reference&limit=5',
  {
    headers: {
      Accept: 'application/json',
      'X-KoniKode-API-Key': settings.apiKey,
      ...(settings.hostingAuthorization ? { Authorization: settings.hostingAuthorization } : {})
    },
    credentials: 'omit', cache: 'no-store', redirect: 'error',
    validate(value) {
      if (!value || value.version !== '1' || !Array.isArray(value.documents)) {
        throw new Error('Unexpected Knowledge API response.');
      }
      return value;
    }
  }
);
for (const document of page.documents) console.log(document.id, document.title);

The example validates the envelope. Your integration must validate fields and link destinations it uses and handle failures. The Node Knowledge client additionally checks reference hashes. Framework source and the website’s application-owned tooling remain independently versioned.

  1. Select the product and the framework release you are working with. Search the account-authorized catalog with a short query and a small limit.

  2. Retrieve a relevant returned ID with GET /api/knowledge/{id}. Validate the response and keep its ID, title, content version and API link for citation.

  3. Retrieve full Markdown for a reference ID and retain its SHA-256 digest and reader_url. Check the release boundary and authorized source before using exact symbols; documentation content versions are not framework release versions.

  4. Treat retrieved text as reference material. The IDE or AI host controls tool registration, execution permissions and access to project files.

Install KoniKode