Jira
Sync Jira issues into your Naumu memory as nodes.
Jira tracks your team's work as "issues" - tickets for bugs, tasks, and features. Connect a Jira site to a Naumu space, and Naumu pulls those issues in as nodes (the items in your memory).
Each issue's fields become node attributes (its properties, like priority or status), and the relationships between issues, projects, and sprints become edges (the connections between nodes). The work your team tracks in Jira becomes part of the same memory you can ask questions of.
The connection works in three steps:
- An admin connects over OAuth - a standard sign-in flow that grants access without sharing a password.
- You pick which projects to bring in, and Naumu does a one-time import of those projects' issues.
- From then on, Naumu keeps your memory in sync as work changes on the Jira side.
Connect a Jira site
Connecting is an admin task, and you do it entirely from inside Naumu - no command line, API key, or external setup required.
Before you start: you must be an owner or admin of the space, and Atlassian allows only one Jira-to-Naumu connection per account - if that account is already connected to another space, disconnect it there first.
- Open the space you want to populate.
- Go to Settings → Integrations.
- In the Jira card, select Connect.
- You are redirected to authorize Naumu. Approve the requested access.
- You are returned to Naumu, which opens the project picker so you can choose what to import.
You can also connect from chat: if you ask Naumu to bring in your Jira work, it drops the same Jira connect card straight into the conversation, so you can start the flow without leaving the thread. It's the same card as the one under Settings → Integrations.
Naumu checks your role before the redirect, so a connection is only ever bound to a space you can administer. A space also connects to one Jira site at a time: if your account can reach more than one site, you'll be asked to pick which one this space syncs with before you choose what to import.
Choose which projects to sync
Once you've connected (and picked a site, if your account reaches more than one), Naumu shows you a checklist of the site's projects and asks which ones to bring in. By default every project is pre-checked; you can clear the ones you don't want, but at least one project has to stay selected - you can't confirm an empty selection. No import runs until you confirm.
There's no separate import-versus-sync toggle: selecting a project imports it once, the first time you select it, then keeps it in sync.
You can change the scope later. While connected, a Manage projects control reopens the same picker:
- Deselecting a project stops its sync, but leaves the nodes it already imported in your memory.
- Re-selecting a project resumes its sync without re-importing.
- A project created in Jira after you connect appears unchecked; selecting it triggers a one-time import for just that project.
How issues become nodes
After you choose your projects, Naumu fetches their issues and proposes how to fit them into the space's schema - the set of node types your memory already uses. Each kind of source item becomes its own Naumu node type:
- Issues. Each Jira issue type (Epic, Story, Task, Sub-task, and so on) becomes its own node type.
- Projects and sprints become their own types, so issues can be grouped under them.
- Members become nodes that issues are assigned to.
The proposal is additive: it never removes, rewrites, or merges into types you already have. Each imported type is its own distinct type, named after its source - a Jira Task becomes Jira Task - even if you already have a same-named type of your own, so imported and authored data never mix within one type.
Naumu narrates the whole import in a dedicated chat thread titled "Importing from Jira": what's coming in, then the schema connections it's proposing between your existing types and the imported ones, then which of your own items it's matched to imported ones (as a change card you can review or undo). You can reply in that thread to steer the schema connections, but the import itself never waits on a reply.
Field mapping
Rather than copying every field word for word, Naumu maps the fields it imports onto a small, consistent set of node attributes and edges. Here's where each field lands:
| Source field | Where it lands in Naumu |
|---|---|
| Issue title | Node label |
| Issue description / body | The node's content |
Issue key (e.g. KAN-42) | A JiraKey attribute |
| Priority | A Priority attribute |
| Status / workflow state | A Status attribute |
| Labels | A Labels multi-select attribute |
| Created / updated time | The node's own created and updated timestamps |
| Project, sprint, assignee, parent | Edges to the related nodes |
Labels are free-form, so Naumu adds new label values to the schema as it encounters them rather than locking in a fixed list up front.
Tracking status and staying in sync
The connection doesn't stop at the first import. As issues change in Jira - a status moves, a new issue is created, a label is added - Naumu updates the matching nodes in near real time. Only issues in the projects you selected sync; changes outside that scope are ignored.
Sync is one-directional: changes flow from Jira into Naumu, never the other way. Synced nodes are read-only in Naumu - Jira stays the source of truth, so you can't rename, delete, or edit a synced issue's attributes from inside Naumu. Each one carries a small "read-only" badge so it's easy to tell apart from nodes you author yourself. To change something, edit it in Jira and the update syncs back automatically.
Disconnecting
Disconnect from the same Settings → Integrations panel. Disconnecting is a soft operation: it clears the access tokens and stops syncing, but the nodes you've already imported stay in your memory. If you reconnect the same site later, Naumu resumes syncing against those existing nodes rather than creating duplicates.