Welcome to Nexyn
Most artificial intelligence memory systems suffer from a major problem. They remember everything forever. Over time, their memory databases become bloated with useless information. This causes slow retrieval times, high computing costs, and poor context quality.
Project Nexyn fixes this problem by mimicking the human brain. We built an intelligent engine that actively learns how to forget. By filtering and naturally decaying low value data, your knowledge graph remains incredibly fast and highly optimized at all times.
The Cognee Architecture
At the core of Project Nexyn lies Cognee. Cognee is a state of the art graph vector database designed for permanent memory retention. However, raw memory without curation eventually turns into noise. We utilized Cognee as the bedrock storage layer, treating it as the long term permanent memory bank.
Instead of blindly injecting every incoming message into Cognee, Nexyn acts as an intelligent shield. It intercepts the data, evaluates it, and only forwards the most critical knowledge to the Cognee cloud using strict application programming interfaces.
The Four Layers
We designed Nexyn using four distinct cognitive layers based on human psychology and ancient philosophy. Each layer performs a specialized function in the memory lifecycle.
Sensory Buffer
This is the first point of contact for all incoming data. Just like your eyes and ears take in huge amounts of raw data every second, this layer briefly holds all new information. It temporarily stores documents, chat logs, and system events before passing them securely to the next stage.
Evaluator
This layer acts as the active intellect of the system. It uses an advanced language model to analyze every piece of data from the sensory buffer. It assigns a valence score based on relevance, emotional weight, and structural importance. Highly important data gets a high score. Useless chatter gets a low score.
Memory Consolidator
Once the data is scored, this layer decides its fate. High scoring data is permanently integrated into the core knowledge graph. This ensures critical facts are never lost. Low scoring data remains in temporary storage where it will naturally fade away.
Ego Decay
Just like human memory fades over time if not accessed, this final layer continuously prunes the system. It routinely scans the temporary storage and permanently deletes data that has decayed past the acceptable threshold. This guarantees that your vector database remains fast, clean, and highly optimized.
The API Wrapper Explained
To interact with the Cognee cloud securely and efficiently, we built a dedicated Python wrapper. This wrapper normalizes data payloads, gracefully handles cloud tenant limits, and securely orchestrates graph operations without crashing the host application.
Explore the interactive tabs below to see exactly how our codebase interfaces with the Cognee endpoints in real time.
Nvidia Inference Integration
The Evaluator layer is powered by Nvidia NIM microservices, specifically utilizing the highly optimized meta/llama-3.1-8b-instruct model. We chose this specific architecture for three critical reasons:
- High-Tier Reasoning: Accurate biological Valence scoring requires deep contextual understanding without hallucinating.
- Ultra-Low Latency: Evaluating massive amounts of incoming data inline requires sub-second response times to prevent pipeline bottlenecks.
- Cost Efficiency: Running a highly optimized 8B model on Nvidia architecture allows for massive scale at a fraction of the cost of larger models.
Ultra Low Latency Valuations
Memory evaluation happens inline before data ever reaches the permanent database. This requires near zero latency. The Nvidia NIM endpoints running LLaMA 3.1 allow us to compute biological valence scores in milliseconds, ensuring your vector ingestion pipeline never lags.
Usage Guide
Getting started is incredibly simple. Our system runs locally and connects directly to your applications with minimal setup required.
Step One: Installation
Install the package via your preferred package manager. Ensure you have Python installed on your machine.
Step Two: Configuration
Navigate to the web dashboard and click the settings icon located near the title. Enter your Nvidia API key and Cognee API key. The system will securely save these credentials and instantly connect to the processing servers in the background.
Step Three: Integration
Send data directly to the ingest endpoints. The biomimetic engine will automatically score the data and route it through the four cognitive layers. You can easily monitor the real time status of your memory graph through the live dashboard.
Cloud vs Open Source Multi-Tenancy
When using Cognee Cloud, every HTTP request is stateless. You must pass tenant_id and user_id into nexyn.inject() so the cloud server knows which memory graph to use.
However, when running Cognee Open Source locally, data isolation is handled natively via context variables. Simply leave the IDs blank in Nexyn, and instead pass dataset_name="user_123" directly into your cognee.add() calls to partition your users' data!
import asyncio
import cognee
import nexyn
async def main():
# 1. Initialize Nexyn's cognitive layer
# For Cognee Cloud: Pass cognee_url and cognee_api_key
# For Cognee Open Source (Local): Leave cognee_url empty
await nexyn.inject(
nim_api_key="nvapi-your-key-here",
cognee_api_key="your_cognee_api_key", # Leave empty for local open source
cognee_url="https://api.cognee.ai", # Leave empty for local open source
tenant_id="default", # Leave empty for local open source
user_id="user_123" # Leave empty for local open source
)
# 2. Add memories normally (Nexyn automatically scores Valence)
await cognee.add("Doug is the groom. The wedding is Sunday.")
# 3. Compile the Cognee knowledge graph
await cognee.cognify()
# 4. Search triggers decay physics and memory rehearsal
results = await cognee.search("Where is Doug?")
# 5. Fast-forward time to prune dead memories
await nexyn.sweep()
if __name__ == "__main__":
asyncio.run(main())