Naxis Technologies DOCS
/
naxistechnologies.com ↗

Product guide

Sources — mail, databases, apps

Connect mailboxes, SQL databases, CRMs, ERPs, issue trackers and support desks.

Set up a Dedicated mailbox (forwards)

Create a dedicated mailbox (e.g. assistant@your-company.com) and tell people to forward anything worth keeping. Each sync reads the mailbox: the message text and its document attachments (PDF, Word, Excel…) become searchable documents. To read an existing mailbox in full instead, use the Full mailbox (auto-read) source.

  1. Create the mailbox with your mail provider and note its IMAP settings (Gmail: imap.gmail.com; Microsoft 365: outlook.office365.com).
  2. If the account has two-factor authentication, create an app password for it (Gmail and Microsoft 365 require this).
  3. Documents → Dedicated mailbox (forwards): enter the IMAP server, the address and the password; choose access groups, Test, then Sync.
After a message is ingestedMove it to an “Ingested” folder (default — keeps the inbox an empty queue), mark it read, delete it, or leave it untouched. Note: in “mark it read” mode only UNREAD mail is picked up — anything a person already opened is never ingested, so prefer “move” on a mailbox people also read.
Archive folderIngested messages are stored permanently in this folder on the Naxis Assistant server — cleaning the mailbox never removes knowledge. Leave the default unless your provider says otherwise.

The same message forwarded twice is ingested once. Everyone in the chosen access groups can ask about what lands in the mailbox — share its address accordingly. Inline images and signatures are skipped; messages over 50 MB are left in the mailbox untouched.

Set up a Full mailbox (auto-read)

Connect an existing mailbox — a shared box like info@ or support@, or a personal account — and every message in it, plus everything that arrives from now on, is read automatically. The mailbox itself is never changed: nothing is moved, marked read or deleted.

  1. Note the account's IMAP settings (Gmail: imap.gmail.com; many hosts: mail.yourdomain.com).
  2. If the account has two-factor authentication, create an app password for it.
  3. Documents → Full mailbox (auto-read): enter the IMAP server, the address and the password; choose access groups carefully (see below), Test, then Sync.
Folders to readBlank reads every folder — including Sent, where the answers your team writes live — except junk, trash and drafts. Or list specific folders, one per line.
Only mail newer thanA cut-off date; older mail is never read. Useful to keep ancient history out.
Ignore sendersAddresses or whole domains whose mail should never be ingested — one per line.

Noise is filtered automatically: junk/trash/drafts folders, messages the server flagged as spam, newsletters and mailing lists, and auto-generated replies are skipped, and quoted reply chains are trimmed so long threads don't repeat themselves. Large mailboxes are ingested progressively over the first syncs. Mind the access groups: everyone in them can ask about anything in this mailbox. Microsoft 365 usually blocks IMAP passwords — your IT can allow them, or use a provider that supports app passwords.

Set up a SQL database (PostgreSQL, MySQL, SQL Server)

Connect a SQL database — PostgreSQL (including Supabase), MySQL / MariaDB, or Microsoft SQL Server — read with a read-only role. It works out the shape of your data from the schema itself: which tables are your customers, invoices and contracts, and how they relate. Each becomes a record the assistant reasons over alongside your documents — “what do we know about this client”, “how much have they been invoiced” — with the figures totalled exactly from the data. Nothing is ever written.

  1. Create a READ-ONLY database role (one that can SELECT but not change anything) with access to the schema you want read.
  2. Supabase: Project → Settings → Database → Connection string — copy it and paste it into the Connection string field.
  3. Any other database: choose the type (PostgreSQL, MySQL/MariaDB or SQL Server), then fill in host, port, database and a read-only username and password; SSL mode covers PostgreSQL and MySQL/MariaDB (SQL Server encrypts when the server requires it).
  4. Optionally limit to specific tables (or exclude some); blank reads the whole schema.
  5. Documents → SQL database, enter the connection, choose access groups, Test, then Sync.

Only SELECTs are ever issued, and the session is additionally opened read-only with a query timeout where the engine supports it (PostgreSQL, MySQL — SQL Server has no session read-only mode, so use a read-only role there). Sensitive columns (passwords, card numbers, salaries…) are never ingested — not in records, samples or totals. Large tables aren't copied row by row: each customer/contract/etc. becomes one record with its figures summarised, refreshed on every sync, and very large tables are bounded — the first 5,000 records per table (the sweep summary says so whenever the cap is hit).

Set up HubSpot (CRM)

Connect a HubSpot CRM portal. It reads your companies, contacts, deals and tickets and how they relate, and turns each into a record the assistant reasons over alongside your documents — “what's the status of this account”, “which deals are open for them”, “what did we last discuss” — with the notes, emails, calls and meetings logged against each brought in as dated activity. Read-only: nothing is ever written back to HubSpot.

  1. Press Connect and sign in to HubSpot — you approve read-only access to your CRM on HubSpot's own page; no credentials are stored here.
  2. If your deployment isn't set up for one-click connect, create a private app in HubSpot (Settings → Integrations → Private apps) with the CRM object read scopes and paste its access token instead.
  3. Choose whether to include logged activity (notes, emails, calls, meetings and attached files) or records only.
  4. Choose access groups, Test, then Sync.

Read-only by construction — only your CRM is read, never changed. Each company, contact, deal and ticket becomes one record with its linked contacts and companies and its figures (open pipeline, deal amounts) summarised, refreshed on every sync. Custom objects are discovered and synced too, and files attached to activity become documents of their own. HubSpot also knows your team — you can import their accounts from this source (see “Import your team”).

Set up Salesforce (CRM)

Connect a Salesforce org. It reads your accounts, contacts, opportunities, cases and leads and how they relate, and turns each into a record the assistant reasons over — account health, open opportunities and their amounts, recent activity — with the tasks, events and files logged against them brought in. Read-only.

  1. Press Connect and sign in to Salesforce — you approve read-only API access; the org's address is resolved automatically at sign-in (the Instance URL field can stay blank).
  2. If your deployment isn't set up for one-click connect, paste the instance URL and an access token in the fields instead.
  3. Sandboxes: pick “Sandbox” as the org type so sign-ins refresh against test.salesforce.com.
  4. Choose access groups, Test, then Sync.

Read-only — only SOQL reads are issued. Opportunity amounts are totalled per account, and the files attached to your synced records become documents (only linked files — never the whole org's file library).

Set up Pipedrive (CRM)

Connect a Pipedrive CRM with an API token. It reads your organizations, people and deals and how they relate, and turns each into a record the assistant reasons over, with the notes, activities and files logged against them. Read-only.

  1. In Pipedrive open Settings → Personal preferences → API and copy your token (use a read-only user where possible).
  2. Documents → Pipedrive, enter your company domain (the <name> in name.pipedrive.com) and paste the token.
  3. Choose access groups, Test, then Sync.

Read-only. Deal values are totalled per organization, and attached files become documents.

Set up Zoho CRM

Connect a Zoho CRM. It reads your accounts, contacts, deals and leads and how they relate, and turns each into a record the assistant reasons over, with the tasks, calls, events and notes logged against them. Read-only.

  1. In the Zoho API console (api-console.zoho.com) create a Self Client, and generate a grant with the ZohoCRM.modules.READ and ZohoCRM.users.READ scopes.
  2. Exchange the grant for a refresh token (Zoho's Self Client screen shows how), and note the client id and secret.
  3. Documents → Zoho CRM, pick your data centre, and paste the client id, secret and refresh token.
  4. Choose access groups, Test, then Sync.

Read-only. Deal amounts are totalled per account. Pick the data centre where the Self Client was created — the refresh token is bound to it (the API address is then read from the account automatically).

Set up Microsoft Dynamics 365 (CRM)

Connect a Microsoft Dynamics 365 org. It reads your accounts, contacts, opportunities, cases and leads and how they relate, and turns each into a record the assistant reasons over, with the tasks, calls, appointments, emails and notes logged against them. Read-only.

  1. Enter your organization URL (https://yourorg.crm.dynamics.com) and save — the sign-in is scoped to YOUR org, so this must come first.
  2. Press Connect and sign in with your Microsoft account — you approve read-only access to your Dynamics org.
  3. If your deployment isn't set up for one-click connect, paste an access token for the org instead.
  4. Choose access groups, Test, then Sync.

Read-only. Opportunity amounts are totalled per account, and note attachments become documents.

Set up Odoo (ERP)

Connect an Odoo ERP. It reads your customers, sales orders, invoices, leads and products and how they relate, and turns each into a record the assistant reasons over — with order and invoice totals summarised per customer, and attached files (invoice PDFs and the like) brought in as documents. Read-only.

  1. In Odoo open Preferences → Account Security → New API Key (or use the user's password); prefer a read-only user.
  2. Documents → Odoo, enter the Odoo URL, database name and login, and paste the API key.
  3. Choose access groups, Test, then Sync.

Read-only — only authenticate, search and read calls are ever made. Only customer invoices and vendor bills count as invoices (journal entries are left out), totals are summarised per customer, and the chatter thread (logged notes and emails) comes in as dated activity. Archived records are not synced.

Set up GitHub (issues & PRs)

Connect GitHub to make the issues and pull requests in your repositories searchable — each becomes a document with its description and full comment thread, tied to its repo, author and labels. Read-only.

  1. Create a personal access token (fine-grained with Contents, Issues and Pull requests read access, or a classic token with the repo scope).
  2. Documents → GitHub, paste the token, and either list owner/repo lines or give an owner — an org syncs its repos; your own username syncs your repos including private ones.
  3. Choose issues, PRs or both; choose access groups, Test, then Sync.

Read-only — only reads are issued. Each repository also becomes a concept with its open/total counts.

Set up GitLab (issues & MRs)

Connect GitLab to make the issues and merge requests in your projects searchable — each becomes a document with its description and notes, tied to its project, author and labels. Works with gitlab.com and self-hosted. Read-only.

  1. Create a personal or project access token with the read_api scope.
  2. Documents → GitLab, paste the token (set your server URL if self-hosted), and list project paths/ids or leave blank for all your projects.
  3. Choose issues, MRs or both; choose access groups, Test, then Sync.

Set up Bitbucket

Connect Bitbucket Cloud to make your issues and pull requests searchable — each becomes a document with its description and comments, tied to its repository. Read-only.

  1. Create an API token at id.atlassian.com → Security → API tokens, with read scopes for repositories, issues and pull requests (legacy app passwords retire in July 2026).
  2. Documents → Bitbucket, enter the workspace, your Atlassian account email (or username, for a legacy app password) and the token; optionally list repo slugs.
  3. Choose access groups, Test, then Sync.

Set up Jira

Connect Jira Cloud to make your issues searchable — each becomes a document with its description and comment thread, tied to its project, assignee and reporter. Read-only.

  1. Create an API token at id.atlassian.com → Security → API tokens.
  2. Documents → Jira, enter your site (your-domain.atlassian.net), the account email and the token.
  3. Optionally limit to project keys or give your own JQL; choose access groups, Test, then Sync.

Read-only. Each project also becomes a findable concept.

Set up Linear

Connect Linear to make your issues searchable — each becomes a document with its description and comments, tied to its team, assignee and labels. Read-only.

  1. Create a personal API key in Linear → Settings → Security & access.
  2. Documents → Linear, paste the key (optionally limit to team keys), choose access groups, Test, Sync.

Read-only. Each team also becomes a concept. Archived issues are included — Linear auto-archives completed issues after a few months, and that history stays searchable here.

Set up Asana

Connect Asana to make your tasks searchable — each becomes a document with its notes and comments, tied to its project and assignee. Read-only.

  1. Create a personal access token in Asana → Settings → Apps → Developer apps.
  2. Documents → Asana, paste the token (optionally a workspace id), choose access groups, Test, then Sync.

Read-only. Each project also becomes a concept.

Set up Trello

Connect Trello to make your cards searchable — each becomes a document with its description and comments, tied to its board, list and labels. Read-only.

  1. Get an API key at trello.com/app-key and authorize a token with read access.
  2. Documents → Trello, paste the key and token; optionally list board ids or board URLs.
  3. Choose whether archived cards are included (they often hold resolved knowledge); choose access groups, Test, then Sync.

Checklists and their tick-state are part of each card's document.

Set up monday.com

Connect monday.com to make your items searchable — each becomes a document with its column values and update thread, tied to its board and the people on it. Read-only.

  1. Get an API token from monday.com → Developers → My access tokens (or Admin → API).
  2. Documents → monday.com, paste the token; optionally list board ids (the number in a board's URL) — blank syncs every active board.
  3. Choose access groups, Test, then Sync.

Mirror and formula columns come back empty from monday.com's API, so they don't appear on the documents.

Set up Zendesk (support)

Connect Zendesk to make your support tickets searchable — each becomes a document with the full conversation, tied to the organization, requester and assignee, so a customer's support history sits alongside everything else known about them. Read-only.

  1. In Zendesk → Admin Center → Apps and integrations → APIs → Zendesk API, add an API token.
  2. Documents → Zendesk, enter the subdomain, an agent email and the token; choose access groups, Test, then Sync.

Read-only — only reads are issued. Archived tickets (Zendesk archives closed tickets after 120 days) are included, so the whole support history stays searchable. Internal agent notes are included too and are labelled as internal in the document.

Set up ServiceNow (ITSM)

Connect ServiceNow to make your records searchable — each incident (or other table row) becomes a document with its description and comment journal, tied to the people it concerns. Read-only.

  1. Use (or create) a read-only integration user with access to the tables you want.
  2. Documents → ServiceNow, enter the instance (name.service-now.com), the username and password, and the tables (one per line; blank = incident — kb_knowledge brings in knowledge-base articles).
  3. Choose access groups, Test, then Sync.

Closed records keep their resolution (close notes) in the document — usually the most valuable part.