Neurite

Neurite

Fractal Graph-of-Thought. Experimental Mind-Mapping for Ai-Agents, Web-Links, Notes, and Code.

Stars: 891

Visit
 screenshot

Neurite is an innovative project that combines chaos theory and graph theory to create a digital interface that explores hidden patterns and connections for creative thinking. It offers a unique workspace blending fractals with mind mapping techniques, allowing users to navigate the Mandelbrot set in real-time. Nodes in Neurite represent various content types like text, images, videos, code, and AI agents, enabling users to create personalized microcosms of thoughts and inspirations. The tool supports synchronized knowledge management through bi-directional synchronization between mind-mapping and text-based hyperlinking. Neurite also features FractalGPT for modular conversation with AI, local AI capabilities for multi-agent chat networks, and a Neural API for executing code and sequencing animations. The project is actively developed with plans for deeper fractal zoom, advanced control over node placement, and experimental features.

README:

Neurite

License: MIT Discord

Introduction

πŸ’‘ neurite.network unleashes a new dimension of digital interface...

...the fractal dimension.

Bridging Fractals and Thought

🧩 Drawing from chaos theory and graph theory, Neurite unveils the hidden patterns and intricate connections that shape creative thinking.

For over a year, we've been iterating out a virtually limitless workspace that blends the mesmerizing complexity of fractals with contemporary mind mapping technique.

Why Fractals?

The Mandelbrot Set is not just an aesthetic choice - fractal logic is ingrained into a countless number of natural and constructed phenomena - from polynomial equations, to art and music - even the cosmic web.

πŸŒ€ Fractals act as the cross-disciplinary framework for non-integer dimensional thought - where conventional notions of 4D spacetime are put into question.

The goal of this project is to grow agentic graphs of fractal creativity & collaboration.

whyfractals

First of its Kind Fractal Zoom

neurite.network is unique in its ability to seamlessly navigate the Mandelbrot set in real time! πŸš€

Movements through the fractal are no longer interrupted at each step. Instead, the rendering persists and regenerates as you interact...

Why Nodes?

Nodes represent text, images, videos, code, and AI agents. Together, they thread a personalized microcosm of your thoughts and inspirations. πŸ”­

neurite.network connects physics simulation of graphs with an underlying fractal topology to kinematically define interactive, iterative, and modular graphs of ideation.

whynodes whynodes2

Complexity Inspires Creativity / Basins Attract

Whether you're a researcher, writer, artist, developer, educator, or simply a curious thinker, Neurite offers a departure from the conventional interface. It's an interactive landscape tracing your ever-branching pathways of thought.

🌐 Available through Github Pages: neurite.network 🌐

⚠️ Warning: Contains zooming, flashing lights, and colors which may not currently be suitable for people with photosensitive epilepsy.

🌱 This is an open-source project in active development, feel feel to join our team on Discord

Table of Contents

  1. Introduction
  2. How to Use Neurite
  3. Synchronized Knowledge Management
  4. FractalGPT
  5. Multi-Agent UI
  6. User Guide
  7. Local Server Setup
  8. Neural API
  9. Future of Neurite
  10. Gallery

How to Use Neurite

πŸ“š Neurite lets you embed anything - text, photos, audio, video, PDFs, AI, and webpages - directly within the Mandelbrot set.

Drag and drop or Paste local files and web content straight into the fractal.

βš™οΈControlsβš™οΈ

Category Key/Combination Action
Navigation Click and drag Move around
Scroll Zoom through the fractal
Node Essentials Shift + double click Create text node
Shift Freeze time
Hold Shift + click Connect two nodes
Double click Anchor a node
Node Selection & Arrangement Alt/Option + Drag Node Arrange the node (avoids text selection)
Alt/Option + Click Select nodes
Alt/Option + Drag Canvas Select multiple nodes
Arrow Keys Move selected nodes
d Scale selected nodes down
f Scale selected nodes up
Fractal Controls Edit Tab Main sliders for fractal rendering and color
Alt/Option + f Freeze the currently displayed fractal lines
Alt/Option + c Clear any frozen lines
Alt/Option + s Save the fractal lines as a PNG

Custom ## title and [[reference]] tags can be set in the Zettelkasten Settings. To access the Zettelkasten Settings, click the note icon in the top left corner of the dropdown.

*Full controls are listed in the ? tab within Neurite's main dropdown.

UI Tips

  • Optimal Node Placement: Zoom in Scroll to create space for new nodes to ensure they have room to expand.
  • Managing Windows: Drag windows by their title bar and resize by scrolling while holding Shift.
  • Freezing Nodes: Hold Shift to freeze nodes in place, then Double Click nodes to anchor them in place.
  • Ai Tutorial: The HOW-TO checkbox sends a context message to the AI that allows it to answer some questions about Neurite.

whynodes3

Synchronized Knowledge Management

Markdown formatted, bi-directional synchronization between UI-focused Mind-Mapping and text-based hyperlinking.

  • FractalGPT: Engage with non-linear, rhizomatic memory through our biomimetic interface.
  • Local AI: Privacy-focused, connect to any locally hosted instance of Ollama or your own custom endpoint.
  • Vector Embeddings: Grow a database of memories that can switch out as context for an increasing number of Ai systems.
  • Chaos and Order: Navigate through the depths of Neurite's non-linear environment at the boundary between stability and disorder.

SKM3

SKM

  • Dynamic Fractal Backdrop: Interactive, multi-media orchestration.
  • Zoom-to-Node: Navigate directly to and between nodes within the Mandelbrot set.
  • Bi-Directional Sync: Real-time updates between Mind Map and Zettelkasten.
  • Zettelkasten and Mind Mapping: Nodes are dynamic objects that can be interacted with from any approach.
  • Endless Exploration: Build custom interfaces within Neurite for any task you have in mind.

Build your Zettelkasten through UI interactions in the Mind Map, and reciprocally shape the Mind Map through text-based note-taking in the Zettelkasten. This navigational fluidity offers unprecedented control over both the granular and macroscopic perspectives of your information.

FractalGPT

Not your typical chat interface

Modular Conversation

In Neurite, you don't just interact with AI; you grow its contextual memory, thanks to:

  • Structured Memory Mapping: Anchor the AI's thought process as notes within an evolving fractal mind map.
  • Graph your AI Conversations: Segment AI's responses into a cohesive web of thought that both improves AI reasoning and allows for the history of your chain of thought to dynamically construct the Ai's memory.
  • Interactive Fractal Network: Neurite's fractal interface acts as a personal, emergent, and contextually aware database of knowledge.
  • Intuitive Note Navigation: Effortlessly access and pull your notes into view, no matter where they are within the fractal landscape.

Fractals are the rabbit hole for endless exploration of thought!

lucky999 FractalGPT

Multi-Agent UI

πŸ€– Build Multi-Agent Chat Networks πŸ€–πŸ’¬πŸ—¨οΈπŸ€–πŸ—¨οΈπŸ€–

  • Connected Ai nodes send messages to one another. This idea contains endless possibilities. (Hold Shift + Click two node windows to connect. Click connections to change their direction. Shift + Double Click to delete.)
  • Supports Local and Cloud based models concurrently.

flow-based Ai-Agents β›“οΈπŸ’­

πŸ”„ Message Looping: Initiate conversational threads across connected AI nodes.

  • Prompt Generation: Upon connection, AI nodes are programmed to end responses with a question or prompt, which is then sent to any other connected nodes.
  • Ai Logic Circuits:
    • Determine Conversation Hierarchy: Take control of Ai conversation flows via Neurite's modular user interface. Adjust the direction of converstion across connected Ai Nodes between two-way, sending, or receiving.
  • Graph Context:
    • Networked Instructions: Ai nodes read all connected graphs.
    • Shared Instructions: Compare Various Ai Models from the same set of prompts.
  • Connect Data:
    • Read Connected Web-Link Nodes: Connect webpages and Ai nodes to utilize RAG search for that document. Create specialized autonomous agent swarms via mind-mapping.
  • Related Research: Conversational Swarm Intelligence Paper

Multi-Agent Chat Networks Multi-Agent Chat Networks3 Multi-Agent Chat Networks2

Unbounded AI Collaboration

An open world generative landscape for thought integrated with artificial intelligence.

AI Inference Providers

Local Cloud
Ollama OpenAI
transformers.js Groq
Custom Anthropic

Neurite Supports the following AI Plugins: ⚑

Plugin Description
Auto Mode Enable the AI to recursively generate its own prompts.
Long-Term Memory Utilize nodal recall through our vector-embedded search of your notes and conversation. Includes experimental ability to forget certain memories.
Experimental Code Editor
  • HTML/JS: Render GPT's code output directly. Connected nodes bundle together any HTML/CSS/JS codeblocks or editors.
  • Python (Pyodide): Execute Python code directly within the browser.
Web Search Utilize the Google programmable search API to retrieve webpages that can be sent as context to the AI.
Understands Webpages and PDFs Leverage a local vector database to extend the AI's context window.
Wikipedia Results Retrieve the top 3 Wikipedia results or shuffle through the top 20.
Wolfram Alpha Results Display Wolfram Pods as nodes.

All API keys can be input through the AI tab in the menu dropdown.

User Guide

To run Neurite locally,

either:

  1. Clone the repository
  2. Navigate to the cloned directory in your terminal (either main or local-ai branch)
  3. Install any necessary global dependencies when running the below, (Vite)
npm install
npm run build
npm start

*optionally run npm start:host to access Neurite from devices connected to the same network.

  1. Navigate to localhost:8080 in your browser.
  2. Ensure the Localhost Servers are running to leverage Neurite's full capabilities.

Local Server Setup

The Localhost Servers are an important component of Neurite that serve as an optional backend and enable complete functionality.

Download Localhost Servers here.

*alternatively clone the entire repo.

The servers enable the local Vector Database, webpage/pdf text extraction, Wolfram Alpha, and Wikipedia.

  • The localhost servers require npm and Node.js
  • Without any servers running, Wolfram, Wiki, the Vector Database and Webpage extractions will not function.
  • All servers can be run with one command. Download the Localhost Servers folder, or find it in your cloned directory. Once navigated to the Localhost Servers folder in your command line, run
  node start_servers.js

This will install and run all of the servers at once. They'll work on our Github pages host of Neurite, or any other way you locally access the interface.

As of our recent update, the servers now support an Ai proxy that connects Neurite to any inference backend.

neuritedemo1

Final Notes

  • Search: Our distinctive search mechanism transports you through your intricate web of thoughts, directly zooming to the node you are looking for. The navigational experience isn't just a gimmick; it also helps to reinforce the spatial memory of where that piece of information resides within the larger framework.
  • Saving: Your networks can be saved within the browser cache, or downloaded as a .txt file. Drag the .txt file into the save box, click load on the imported file, then click the second load button to display the network. πŸ’Ύ Saving has been significantly enhanced! Now, node interactivity, fractal settings, and the Zettelkasten sync all fully restore when loading networks from the save tab...
  • Zettelkasten and Mind Mapping: Create nodes through custom-defined syntax, or create nodes through UI interaction within our fractal workspace, who's contents are bi-directionally linked to the main Zettelkasten document.
  • Fractals: We achieve real-time navigation of the Mandelbrot set by capturing a sparse set of points from the fractal and connecting them through SVGs. From there, we dynamically adapt the level of detail based on your viewport and cursor position. This evolving method is what ensures seamless fractal generation, interaction, as well as an expanding array of customizability options.

Neurite realizes tapestry of thought reasoning for Ai, all within our innovative real-time Mandelbrot visualization.

  • Talk to the custom GPT, Neurite GPT with access to Neurite's code and readme. (This is not the ai that interacts with Neurite itself)

Long Term Memory for Ai

  • Neurite incorporates note-taking to retain a non-linear conversation history.
  • We feed both the recent conversation as well as any matched notes that are not already in the recent conversation as part of the context message to the Ai.
  • This means retaining relevant information from any part of the conversation regardless of the Ai's context window size.
  • Still, advancements in context window size only further enable Neurite's performance.

AI Integration Diagram

Neural API

neuralapi

Expirimental Update: Function Calling Panel

This feature is a terminal that allows you to execute Neurite's code from within Neurite itself.

Included with the function calling panel update is our Neural API. The Neural API is a growing collection of existing features within Neurite, made for sequencing animations of function calls. The current features include:

  • Animate movements through the Mandelbrot set
  • Determine exact coordinates to zoom to
  • Call GPT 4 Vision to determine the next movement (set number of iterations)
  • Create notes
  • Prompt the Zettelkasten Ai
  • Prompt the user
  • Search and Zoom to Notes

You can call on GPT to construct the sequences of function calls itself. It has access to the documentation.

For the current documentation, try calling the below from within the function panel:

const neuralAPI = neuralApiPrompt();
console.log(neuralAPI);

The current Neural API documentation will display in your call history for the function calling panel as well as in your browser console.

There will be more information on this soon. This is a new feature in initial release.

Future of Neurite

Neurite is a recursive environment for generating ideas. The project combines fractals, mind-mapping, and ai to enable an experimental, yet powerful playground for research, code generation, writing, learning, and visualizing thought.

🚧 Neurite is in active development. 🚧

βœ… Ollama (local Ai)

βœ… local embeddings

  • VR

πŸ”„ deeper fractal zoom

βœ… Global Function Calling

βœ… Cellular Automata

βœ… Multi-Agent Chat

βœ… Advanced Control over Node Placement

βœ… color selection

βœ… adjust fractal generation (width, length, max lines, speed)

βœ… screen recording

βœ… Improved Saving

πŸ”„ accessibility

βœ… Expanded fractal types. (Mandelbrot, Burning Ship, Julia Sets)

  • drawing-tool

πŸ”„ Experimental Features

πŸ”„ user feedback/bug fixes

πŸ”„ pull requests

🚧

Gallery

If you are a developer who is interested in contributing to this project, contact us at [email protected] or visit our discord πŸ”—

whyfractals3 whyfractals2 whyfractals whyfractals4 whyfractals6 whyfractals5 SKM2 SKM SKM3

Star History Chart

For Tasks:

Click tags to check more tools for each tasks

For Jobs:

Alternative AI tools for Neurite

Similar Open Source Tools

For similar tasks

For similar jobs