Migration

If you have ideas scattered across Notion databases, Obsidian vaults, or other tools, NeuralRepo makes it straightforward to bring them all into one place.

Caution

Check two Free-plan ceilings before you start a bulk import. A Free account stops accepting new ideas at 50 unarchived ideas — POST /ideas returns 403 idea_limit_reached, and there is no way to delete your way back under the cap that recovers the imported ideas. Free is also capped at 100 API requests per day, so an import of a few hundred rows needs Pro or several days. The CLI path has the same limits: nrepo push is the same endpoint.

From Notion

1. Export from Notion. Open your Notion database, click the ... menu, and select Export. Choose CSV or Markdown & CSV format. Unzip the downloaded file.

2. Map fields. Notion properties map to NeuralRepo fields as follows:

   Notion Property	NeuralRepo Field	Notes
   Name / Title	title	Required
   Notes / Content	body	Supports markdown
   Tags (multi-select)	tags	Array of strings
   Status (select)	status	Map to: captured, exploring, building, shipped, shelved
   URL	source_url	Optional

3. Import via API. Use a script to read the CSV and push each row:

   #!/bin/bash
   API_KEY="nrp_your_key_here"
   API_URL="https://neuralrepo.com/api/v1/ideas"
   
   # Skip header line, read CSV
   tail -n +2 exported.csv | while IFS=',' read -r title body tags status; do
     # Convert comma-separated tags to JSON array
     tags_json=$(echo "$tags" | sed 's/;/","/g' | sed 's/^/["/' | sed 's/$/"]/')
   
     curl -s -X POST "$API_URL" \
       -H "X-API-Key: $API_KEY" \
       -H "Content-Type: application/json" \
       -d "{
         \"title\": \"$title\",
         \"body\": \"$body\",
         \"tags\": $tags_json,
         \"status\": \"captured\"
       }"
   
     echo " -> Imported: $title"
   done

Caution

For large exports (100+ ideas), add a short delay between API calls to avoid rate limiting. Insert sleep 0.5 after each curl command.

From Obsidian

Obsidian vaults are folders of markdown files, which makes migration straightforward.

1. Identify your ideas folder. If your vault has a specific folder for ideas (e.g., Ideas/ or Inbox/), use that. Otherwise, you can import the entire vault.

2. Push each file via CLI.

   for file in ~/obsidian-vault/Ideas/*.md; do
     title=$(head -1 "$file" | sed 's/^# //')
     body=$(cat "$file")
     nrepo push "$title" --body "$body" --tag obsidian --tag imported
   done

3. Handle frontmatter. If your Obsidian notes use YAML frontmatter with tags, you can extract them:

   for file in ~/obsidian-vault/Ideas/*.md; do
     title=$(head -1 "$file" | sed 's/^# //')
     body=$(cat "$file")
     # Extract tags from frontmatter (assumes format: tags: [tag1, tag2])
     tags=$(grep '^tags:' "$file" | sed 's/tags: \[//' | sed 's/\]//' | tr -d ' ')
   
     if [ -n "$tags" ]; then
       IFS=',' read -ra tag_array <<< "$tags"
       tag_flags=""
       for t in "${tag_array[@]}"; do tag_flags="$tag_flags --tag $t"; done
       nrepo push "$title" --body "$body" $tag_flags
     else
       nrepo push "$title" --body "$body" --tag obsidian
     fi
   done

From Plain Text or JSON

If you have ideas in a JSON file, you can import them directly:

[
  {
    "title": "Build a habit tracker",
    "body": "Mobile app with streak counting and push notifications",
    "tags": ["mobile", "react-native"]
  },
  {
    "title": "API rate limiter library",
    "body": "Token bucket implementation for Express middleware",
    "tags": ["api", "node"]
  }
]

#!/bin/bash
API_KEY="nrp_your_key_here"

# Use jq to iterate over the array
jq -c '.[]' ideas.json | while read -r idea; do
  curl -s -X POST "https://neuralrepo.com/api/v1/ideas" \
    -H "X-API-Key: $API_KEY" \
    -H "Content-Type: application/json" \
    -d "$idea"

  echo " -> Imported: $(echo "$idea" | jq -r '.title')"
  sleep 0.3
done

Using the CLI for Bulk Import

The nrepo CLI supports pushing from files directly:

# Single idea from a file
nrepo push "My idea" --body "$(cat ./idea.md)" --tag imported

# Batch import with a loop
for file in ./ideas/*.md; do
  filename=$(basename "$file" .md)
  nrepo push "$filename" --body "$(cat "$file")" --tag imported
done

Tip

After importing, run a search for common terms to verify your ideas are indexed. NeuralRepo processes embeddings asynchronously, so semantic search results may take a few seconds to appear for newly imported ideas.

What Happens to Imported Ideas

Each import lands in D1 immediately and then goes through the background pipeline, so a few things appear on their own a few seconds later:

• Auto-tags, on any idea you imported with zero tags. Pro gets AI-suggested tags drawn from your existing vocabulary; Free borrows tags shared by at least two similar neighbours. Import with tags and neither runs.
• related relations, between any pair scoring above your related threshold (default 0.5).
• Duplicate detections, above your dedup threshold (default 0.75). A bulk import of overlapping notes is exactly the situation that generates a lot of these.

Both thresholds are yours to move, in Settings ▸ Search or via search_threshold, dedup_threshold, and related_threshold — each clamped to 0.1–0.9. Raising dedup_threshold before a messy import keeps the duplicate queue manageable.

Post-Migration Checklist

After importing, take these steps to organize your new repository:

• Review tags. Consolidate similar tags (e.g., js and javascript) using the web dashboard.
• Set statuses. Imported ideas default to captured. Move active ones to exploring or building. Anything left in captured past your stale threshold will start showing up in nudge emails and the review queue.
• Create relations. Link related ideas together (Pro). The mind map in the web app helps visualize clusters.
• Check for duplicates. Detection runs automatically on import, but reviewing the results is Pro — on Free, GET /ideas/duplicates always returns an empty list.
• Leave the junk alone until you are sure. Archiving is one-way: DELETE /ideas/:id and nrepo rm set is_archived = 1, delete the search vector, and nothing in the product can bring the idea back. Archived ideas are also excluded from every export, so an export taken afterwards will not contain them either.

Next Steps

Tags Organize your imported ideas with a consistent tagging system.

Duplicate Detection Tune the thresholds and work through what a bulk import surfaces.

Semantic Search Learn how NeuralRepo indexes and searches your ideas.

Exporting Your Ideas The reverse trip — JSON, CSV, or an Obsidian-ready Markdown vault.

Plans & Pricing The idea cap, request budget, and which review tools need Pro.