Uncategorized

In this tutorial, we dive into the cutting edge of Agentic AI by building a “Zettelkasten” memory system, a “living” architecture that organizes information much like the human brain. We move beyond standard retrieval methods to construct a dynamic knowledge graph where an agent autonomously decomposes inputs into atomic facts, links them semantically, and even “sleeps” to consolidate memories into higher-order insights. Using Google’s Gemini, we implement a robust solution that addresses real-world API constraints, ensuring our agent stores data and also actively understands the evolving context of our projects. Check out the FULL CODES here. Copy CodeCopiedUse a different Browser !pip install -q -U google-generativeai networkx pyvis scikit-learn numpy import os import json import uuid import time import getpass import random import networkx as nx import numpy as np import google.generativeai as genai from dataclasses import dataclass, field from typing import List from sklearn.metrics.pairwise import cosine_similarity from IPython.display import display, HTML from pyvis.network import Network from google.api_core import exceptions def retry_with_backoff(func, *args, **kwargs): max_retries = 5 base_delay = 5 for attempt in range(max_retries): try: return func(*args, **kwargs) except exceptions.ResourceExhausted: wait_time = base_delay * (2 ** attempt) + random.uniform(0, 1) print(f” Quota limit hit. Cooling down for {wait_time:.1f}s…”) time.sleep(wait_time) except Exception as e: if “429” in str(e): wait_time = base_delay * (2 ** attempt) + random.uniform(0, 1) print(f” Quota limit hit (HTTP 429). Cooling down for {wait_time:.1f}s…”) time.sleep(wait_time) else: print(f” Unexpected Error: {e}”) return None print(” Max retries reached.”) return None print(“Enter your Google AI Studio API Key (Input will be hidden):”) API_KEY = getpass.getpass() genai.configure(api_key=API_KEY) MODEL_NAME = “gemini-2.5-flash” EMBEDDING_MODEL = “models/text-embedding-004″ print(f” API Key configured. Using model: {MODEL_NAME}”) We begin by importing essential libraries for graph management and AI model interaction, while also securing our API key input. Crucially, we define a robust retry_with_backoff function that automatically handles rate limit errors, ensuring our agent gracefully pauses and recovers when the API quota is exceeded during heavy processing. Check out the FULL CODES here. Copy CodeCopiedUse a different Browser @dataclass class MemoryNode: id: str content: str type: str embedding: List[float] = field(default_factory=list) timestamp: int = 0 class RobustZettelkasten: def __init__(self): self.graph = nx.Graph() self.model = genai.GenerativeModel(MODEL_NAME) self.step_counter = 0 def _get_embedding(self, text): result = retry_with_backoff( genai.embed_content, model=EMBEDDING_MODEL, content=text ) return result[’embedding’] if result else [0.0] * 768 We define the fundamental MemoryNode structure to hold our content, types, and vector embeddings in an organized data class. We then initialize the main RobustZettelkasten class, establishing the network graph and configuring the Gemini embedding model that serves as the backbone of our semantic search capabilities. Check out the FULL CODES here. Copy CodeCopiedUse a different Browser def _atomize_input(self, text): prompt = f””” Break the following text into independent atomic facts. Output JSON: {{ “facts”: [“fact1”, “fact2”] }} Text: “{text}” “”” response = retry_with_backoff( self.model.generate_content, prompt, generation_config={“response_mime_type”: “application/json”} ) try: return json.loads(response.text).get(“facts”, []) if response else [text] except: return [text] def _find_similar_nodes(self, embedding, top_k=3, threshold=0.45): if not self.graph.nodes: return [] nodes = list(self.graph.nodes(data=True)) embeddings = [n[1][‘data’].embedding for n in nodes] valid_embeddings = [e for e in embeddings if len(e) > 0] if not valid_embeddings: return [] sims = cosine_similarity([embedding], embeddings)[0] sorted_indices = np.argsort(sims)[::-1] results = [] for idx in sorted_indices[:top_k]: if sims[idx] > threshold: results.append((nodes[idx][0], sims[idx])) return results def add_memory(self, user_input): self.step_counter += 1 print(f”n [Step {self.step_counter}] Processing: “{user_input}””) facts = self._atomize_input(user_input) for fact in facts: print(f” -> Atom: {fact}”) emb = self._get_embedding(fact) candidates = self._find_similar_nodes(emb) node_id = str(uuid.uuid4())[:6] node = MemoryNode(id=node_id, content=fact, type=’fact’, embedding=emb, timestamp=self.step_counter) self.graph.add_node(node_id, data=node, title=fact, label=fact[:15]+”…”) if candidates: context_str = “n”.join([f”ID {c[0]}: {self.graph.nodes[c[0]][‘data’].content}” for c in candidates]) prompt = f””” I am adding: “{fact}” Existing Memory: {context_str} Are any of these directly related? If yes, provide the relationship label. JSON: {{ “links”: [{{ “target_id”: “ID”, “rel”: “label” }}] }} “”” response = retry_with_backoff( self.model.generate_content, prompt, generation_config={“response_mime_type”: “application/json”} ) if response: try: links = json.loads(response.text).get(“links”, []) for link in links: if self.graph.has_node(link[‘target_id’]): self.graph.add_edge(node_id, link[‘target_id’], label=link[‘rel’]) print(f” Linked to {link[‘target_id’]} ({link[‘rel’]})”) except: pass time.sleep(1) We construct an ingestion pipeline that decomposes complex user inputs into atomic facts to prevent information loss. We immediately embed these facts and use our agent to identify and create semantic links to existing nodes, effectively building a knowledge graph in real time that mimics associative memory. Check out the FULL CODES here. Copy CodeCopiedUse a different Browser def consolidate_memory(self): print(f”n [Consolidation Phase] Reflecting…”) high_degree_nodes = [n for n, d in self.graph.degree() if d >= 2] processed_clusters = set() for main_node in high_degree_nodes: neighbors = list(self.graph.neighbors(main_node)) cluster_ids = tuple(sorted([main_node] + neighbors)) if cluster_ids in processed_clusters: continue processed_clusters.add(cluster_ids) cluster_content = [self.graph.nodes[n][‘data’].content for n in cluster_ids] prompt = f””” Generate a single high-level insight summary from these facts. Facts: {json.dumps(cluster_content)} JSON: {{ “insight”: “Your insight here” }} “”” response = retry_with_backoff( self.model.generate_content, prompt, generation_config={“response_mime_type”: “application/json”} ) if response: try: insight_text = json.loads(response.text).get(“insight”) if insight_text: insight_id = f”INSIGHT-{uuid.uuid4().hex[:4]}” print(f” Insight: {insight_text}”) emb = self._get_embedding(insight_text) insight_node = MemoryNode(id=insight_id, content=insight_text, type=’insight’, embedding=emb) self.graph.add_node(insight_id, data=insight_node, title=f”INSIGHT: {insight_text}”, label=”INSIGHT”, color=”#ff7f7f”) self.graph.add_edge(insight_id, main_node, label=”abstracted_from”) except: continue time.sleep(1) def answer_query(self, query): print(f”n Querying: “{query}””) emb = self._get_embedding(query) candidates = self._find_similar_nodes(emb, top_k=2) if not candidates: print(“No relevant memory found.”) return relevant_context = set() for node_id, score in candidates: node_content = self.graph.nodes[node_id][‘data’].content relevant_context.add(f”- {node_content} (Direct Match)”) for n1 in self.graph.neighbors(node_id): rel = self.graph[node_id][n1].get(‘label’, ‘related’) content = self.graph.nodes[n1][‘data’].content relevant_context.add(f” – linked via ‘{rel}’ to: {content}”) context_text = “n”.join(relevant_context) prompt = f””” Answer based ONLY on context. Question: {query} Context: {context_text} “”” response = retry_with_backoff(self.model.generate_content, prompt) if response: print(f” Agent Answer:n{response.text}”) We implement the cognitive functions of our agent, enabling it to “sleep” and consolidate dense memory clusters into higher-order insights. We also define the query logic that traverses these connected paths, allowing the agent to reason across multiple hops in the graph to answer complex questions. Check out the FULL CODES here. Copy CodeCopiedUse a different Browser def show_graph(self): try: net = Network(notebook=True, cdn_resources=’remote’, height=”500px”, width=”100%”, bgcolor=’#222222′, font_color=’white’) for n, data in self.graph.nodes(data=True): color = “#97c2fc” if data[‘data’].type == ‘fact’ else “#ff7f7f” net.add_node(n, label=data.get(‘label’, ”), title=data[‘data’].content, color=color) for u, v, data in self.graph.edges(data=True): net.add_edge(u, v, label=data.get(‘label’, ”)) net.show(“memory_graph.html”) display(HTML(“memory_graph.html”)) except Exception as e:

arXiv:2509.26226v2 Announce Type: replace-cross Abstract: Reinforcement Learning with Verifiable Reward (RLVR) effectively solves complex tasks but demands extremely long context lengths during training, leading to substantial computational costs. While multi-stage training can partially mitigate this, starting with overly short contexts often causes irreversible performance degradation, ultimately failing to reduce overall training compute significantly. In this paper, we introduce **T**hinking-**F**ree **P**olicy **I**nitialization (**TFPI**), a simple yet effective adaptation to RLVR that bridges long Chain-of-Thought (CoT) distillation and standard RLVR. TFPI employs a simple *ThinkFree* operation, explicitly discarding the thinking content via a direct ** append, to reduce token usage during inference. Training with *ThinkFree*-adapted inputs improves performance and lowers token consumption, even in the original slow-thinking mode. Extensive experiments across various benchmarks have shown that TFPI accelerates RL convergence, achieves a higher performance ceiling, and yields more token-efficient reasoning models without specialized rewards or complex training designs. With TFPI only, we train a 4B model to reach 89.0% accuracy on AIME24 and 65.5% on LiveCodeBench using less than 4K H20 hours.

arXiv:2512.20848v1 Announce Type: new Abstract: We present Nemotron 3 Nano 30B-A3B, a Mixture-of-Experts hybrid Mamba-Transformer language model. Nemotron 3 Nano was pretrained on 25 trillion text tokens, including more than 3 trillion new unique tokens over Nemotron 2, followed by supervised fine tuning and large-scale RL on diverse environments. Nemotron 3 Nano achieves better accuracy than our previous generation Nemotron 2 Nano while activating less than half of the parameters per forward pass. It achieves up to 3.3x higher inference throughput than similarly-sized open models like GPT-OSS-20B and Qwen3-30B-A3B-Thinking-2507, while also being more accurate on popular benchmarks. Nemotron 3 Nano demonstrates enhanced agentic, reasoning, and chat abilities and supports context lengths up to 1M tokens. We release both our pretrained Nemotron 3 Nano 30B-A3B Base and post-trained Nemotron 3 Nano 30B-A3B checkpoints on Hugging Face.

arXiv:2512.20634v1 Announce Type: cross Abstract: Catastrophic forgetting remains a fundamental challenge in continual learning for large language models. Recent work revealed that performance degradation may stem from spurious forgetting caused by task alignment disruption rather than true knowledge loss. However, this work only qualitatively describes alignment, relies on post-hoc analysis, and lacks automatic distinction mechanisms. We introduce the shallow versus deep alignment framework, providing the first quantitative characterization of alignment depth. We identify that current task alignment approaches suffer from shallow alignment – maintained only over the first few output tokens (approximately 3-5) – making models vulnerable to forgetting. This explains why spurious forgetting occurs, why it is reversible, and why fine-tuning attacks are effective. We propose a comprehensive framework addressing all gaps: (1) quantitative metrics (0-1 scale) to measure alignment depth across token positions; (2) real-time detection methods for identifying shallow alignment during training; (3) specialized analysis tools for visualization and recovery prediction; and (4) adaptive mitigation strategies that automatically distinguish forgetting types and promote deep alignment. Extensive experiments on multiple datasets and model architectures (Qwen2.5-3B to Qwen2.5-32B) demonstrate 86.2-90.6% identification accuracy and show that promoting deep alignment improves robustness against forgetting by 3.3-7.1% over baselines.

arXiv:2512.20929v1 Announce Type: cross Abstract: Human language processing relies on the brain’s capacity for predictive inference. We present a machine learning framework for decoding neural (EEG) responses to dynamic visual language stimuli in Deaf signers. Using coherence between neural signals and optical flow-derived motion features, we construct spatiotemporal representations of predictive neural dynamics. Through entropy-based feature selection, we identify frequency-specific neural signatures that differentiate interpretable linguistic input from linguistically disrupted (time-reversed) stimuli. Our results reveal distributed left-hemispheric and frontal low-frequency coherence as key features in language comprehension, with experience-dependent neural signatures correlating with age. This work demonstrates a novel multimodal approach for probing experience-driven generative models of perception in the brain.

arXiv:2512.21107v1 Announce Type: new Abstract: Safety for Large Language Models (LLMs) has been an ongoing research focus since their emergence and is even more relevant nowadays with the increasing capacity of those models. Currently, there are several guardrails in place for all public LLMs and multiple proposed datasets for training safety classifiers. However, training these safety classifiers relies on large quantities of labeled data, which can be problematic to acquire, prone to labeling errors, or often include synthetic data. To address these issues, we suggest a different approach: utilizing semi-supervised learning techniques, which leverage both labeled and unlabeled data, to improve the performance on the safety task. We analyze the improvements that these techniques can offer for both prompts given to Large Language Models and the responses to those requests. Moreover, since augmentation is the central part of semi-supervised algorithms, we demonstrate the importance of using task-specific augmentations, which significantly increase the performance when compared to general-purpose augmentation techniques.

arXiv:2509.16189v3 Announce Type: replace-cross Abstract: When do machine learning systems fail to generalize, and what mechanisms could improve their generalization? Here, we draw inspiration from cognitive science to argue that one weakness of parametric machine learning systems is their failure to exhibit latent learning — learning information that is not relevant to the task at hand, but that might be useful in a future task. We show how this perspective links failures ranging from the reversal curse in language modeling to new findings on agent-based navigation. We then highlight how cognitive science points to episodic memory as a potential part of the solution to these issues. Correspondingly, we show that a system with an oracle retrieval mechanism can use learning experiences more flexibly to generalize better across many of these challenges. We also identify some of the essential components for effectively using retrieval, including the importance of within-example in-context learning for acquiring the ability to use information across retrieved examples. In summary, our results illustrate one possible contributor to the relative data inefficiency of current machine learning systems compared to natural intelligence, and help to understand how retrieval methods can complement parametric learning to improve generalization. We close by discussing some of the links between these findings and prior results in cognitive science and neuroscience, and the broader implications.