Load the MIM
Stream the ACI Managed Information Model that matches your APIC release directly from Cisco DevNet — class by class, into your own Neo4j, no bundle shipped with Fabrik.
Fabrik needs a copy of the ACI Managed Information Model in its Neo4j store before the query builder can do anything useful. The MIM is what makes the canvas intelligent: it knows that fvBD contains fvSubnet, that fvTenant has a property called name, and which class can legally live under which other class. Without it, you can sign in and look around, but you can't build a query.
Fabrik does not discover the MIM from your live APIC, and it does not ship a bundled copy. Instead, your Fabrik container fetches the metadata directly from Cisco's public DevNet pubhub (pubhub.devnetcloud.com) the first time an admin asks for it. Every Fabrik instance loads its own copy, on demand, into its own Neo4j.
Who can do this
MIM Management is admin-only. If you're not an administrator, the sidebar won't even show the entry, and none of the URLs below will resolve for you. Ask your admin to complete this step — you'll pick up from Connect an APIC when the MIM is in place.
For admins, the page lives at Settings → MIM Management (sidebar) or directly at /settings/mim-management.
How it works in one paragraph
You pick an APIC version (5.2.X / 6.0.X / 6.1.X). Fabrik downloads each class's JSON file from DevNet into a temporary directory on disk, parses the lot, and writes it into Neo4j in two passes — class nodes and properties first, relationships second so MERGE never invents stub classes. When the run finishes, the temp directory is deleted and full-text search indexes are built. The whole thing takes about half an hour the first time, and Postgres stays untouched apart from a small audit row.
Two tabs, one page
Settings → MIM Management has two tabs:
| Tab | Purpose |
|---|---|
| Overview | What's currently loaded — version, class count, import history. |
| Cisco DevNet | The version picker that starts a fresh import from pubhub. |
The old "GitHub Bundles" and "Upload" tabs were removed in 2026: they relied on shipping or hand-uploading a JSON bundle, which conflicts with the open-source distribution model. Everything goes through DevNet now.
Checking what's already loaded
Open Settings → MIM Management. The Overview tab is the first thing you see.
If a MIM is loaded, the Currently Installed card shows the APIC version, an Active badge, and three counters: Classes, Properties, Relationships. Below it, the Import History table lists the most recent imports with timestamps and the user who triggered each.
If no MIM is loaded, the card shows an empty state and points you at the Cisco DevNet tab.
Installing from Cisco DevNet
Open the Cisco DevNet tab.
Pick the APIC version
The dropdown lists every supported pubhub version (5.2.X, 6.0.X, 6.1.X). Each entry shows the class count for that release; pick the one that matches your fabric.
If a class is missing from your chosen version (it happens — pubhub occasionally fails to publish a single class), Fabrik automatically falls back to the next version in the chain and tags that class with a sourceVersion so you can see where it came from later.
Choose how aggressively to download (1–10 parallel)
The Parallel downloads slider controls how many concurrent HTTP requests Fabrik makes against DevNet. The default is 10, which is also the maximum. Drop it lower only if your corporate network rate-limits parallel HTTPS to pubhub.devnetcloud.com.
The estimated time on the right of the slider updates as you change the value. At concurrency 10 a fresh 6.1 import is ~30 minutes; lower settings are proportionally slower.
Click Start import
If a different MIM is already loaded, Fabrik shows a confirmation dialog before replacing it. The old graph is wiped and the new one is written in its place — the replacement is not reversible without another import.
The page swaps to a progress card. You can leave the page; the import keeps running in the background and will reattach to the same card the next time you open the page.
Watch the progress
The progress card cycles through three phases:
| Phase | What happens | Approximate share of total time |
|---|---|---|
| Downloading | Per-class JSON files land in /tmp/fabrik_mim_import/<run_id>/. | ~40% |
| Importing | Neo4j is wiped, then nodes + properties + relationships are written in chunked batches. Temp files are deleted as they're consumed. | ~55% |
| Finalizing | Full-text search indexes (class_search, property_search) are built; audit row is recorded. | ~5% |
Counters on the card show how many classes used a fallback version, how many were not found in any version, and how many failed outright. A typical clean import shows zero of each except fallback (small numbers there are normal).
Confirm on Overview
When the import finishes, the Overview tab refreshes automatically. Your new version appears as Active with an up-to-date timestamp and your username.
What gets bundled with Fabrik (and what doesn't)
Fabrik's repository ships only:
- URL templates for
pubhub.devnetcloud.com— facts, not copyrighted. - Slim class lists (
{pkg, class}pairs) per supported version, ~75 KB gzip each. Identifiers, not descriptive content.
Everything else — property definitions, comments, validators, relationships, fault tables — is downloaded by your container at install time and lives only in your local Neo4j. Fabrik never redistributes Cisco-authored MIM content; each installation pulls its own copy from the same public source Cisco serves to every developer who opens the docs in a browser.
Cancelling and resuming
The progress card has a Cancel button while phases 1 or 2 are running. Pressing it sets a cancel flag; the importer finishes the current chunk (so Neo4j is never left in a torn state) and then stops. Pending classes stay in Postgres marked as pending so they can be retried later.
A cancelled or failed run can be resumed from the progress card or from the Cisco DevNet tab. Resume re-dispatches the same Celery task; jobs that already finished are skipped, only the leftover work runs.
Troubleshooting
Problems you're likely to hit, and what they usually mean:
- "DNS resolution failed for pubhub.devnetcloud.com" — your container can't reach the public internet. DevNet is the only source for MIM content; offline installs are not currently supported. (If this is a hard requirement for your environment, raise an issue — bundled MIM may return as an opt-in path.)
- A few classes show
not_foundafter the import finishes — pubhub occasionally fails to publish a single class for a given release. The fallback chain handles most of these silently; the residue is logged on the run row in Postgres but does not fail the import. - Import stalls on the same chunk repeatedly — check the backend container logs (
docker compose logs backend celery-worker) for Neo4j errors. The most common cause is a transaction-memory limit in Neo4j; the chunk size (500 rows) is tuned to stay below the default 1 GiB. If you've shrunk Neo4j further in your.env, raise it back. - The whole import is much slower than 30 minutes — your network's HTTP latency to AWS CloudFront (where pubhub is hosted) is dominant, not concurrency. From Europe expect 200–400 ms per request; from inside an enterprise proxy, sometimes more. Drop the concurrency to 5 if you're seeing 429s; otherwise just wait.
- Browser closes mid-import — fine. Reopen MIM Management; the in-flight run reattaches automatically over the WebSocket and the REST polling.
With a MIM loaded, Fabrik has everything it needs to reason about ACI. The next step is to point it at a live fabric — continue with Connect an APIC.