RAG Memory
Creates a persistent knowledge graph with vector search that stores documents, entities, and relationships for intelligent information retrieval. Combines traditional graph-based connections with semantic similarity search.
What it does
- Store and chunk documents for processing
- Create entities and relationships in knowledge graph
- Perform hybrid search combining vector similarity with graph traversal
- Generate semantic embeddings for documents and entities
- Add observations to continuously enrich entity context
- Extract potential entity terms from documents
Best for
Tools (20)
<description> Create multiple new entities in the knowledge graph with comprehensive metadata and observations. **Essential for building the foundational structure of your knowledge representation.** Use this tool to add new concepts, people, places, or any identifiable objects to your graph. </description> <importantNotes> - (!important!) **Entities are the building blocks** of your knowledge graph - use descriptive names - (!important!) EntityType helps categorize and filter entities (e.g., PERSON, CONCEPT, PLACE, TECHNOLOGY) - (!important!) Observations provide context and evidence for the entity's existence or properties - (!important!) **Avoid duplicate entities** - check if similar entities exist first using search_nodes </importantNotes> <whenToUseThisTool> - When introducing new concepts, people, or objects into your knowledge base - When processing documents and need to extract and formalize key entities - When building domain-specific knowledge representations - When creating structured data from unstructured text - **Before creating relationships** - ensure both entities exist - When migrating knowledge from other systems into the graph </whenToUseThisTool> <features> - Batch creation of multiple entities in a single operation - Automatic unique ID generation based on entity names - Support for custom entity types for domain categorization - Rich observation arrays for evidence and context - Automatic deduplication (existing entities are ignored) - Metadata support for extensible entity properties </features> <bestPractices> - Use consistent naming conventions (e.g., "John Smith" not "john smith") - Choose meaningful entityTypes that reflect your domain (PERSON, TECHNOLOGY, CONCEPT, etc.) - Include rich observations that provide context and evidence - Group related entity creation for better performance - Use descriptive names that uniquely identify the entity - Consider hierarchical naming for complex domains (e.g., "JavaScript.React.Hooks") </bestPractices> <parameters> - entities: Array of entity objects, each containing: - name: Unique identifier/name for the entity (string, required) - entityType: Category/classification of the entity (string, required) - observations: Array of contextual information and evidence (string[], required) </parameters> <examples> - Adding people: {"entities": [{"name": "Albert Einstein", "entityType": "PERSON", "observations": ["Physicist who developed relativity theory", "Nobel Prize winner in 1921"]}]} - Adding concepts: {"entities": [{"name": "Machine Learning", "entityType": "CONCEPT", "observations": ["Subset of artificial intelligence", "Focuses on learning from data"]}]} - Adding technologies: {"entities": [{"name": "React", "entityType": "TECHNOLOGY", "observations": ["JavaScript library for building UIs", "Developed by Facebook"]}]} </examples>
<description> Create multiple relationships between entities in the knowledge graph to establish connections and semantic links. **Critical for building the interconnected structure that makes knowledge graphs powerful.** Relationships define how entities relate to each other, enabling graph traversal and inference. </description> <importantNotes> - (!important!) **Both entities must exist** before creating relationships - entities are auto-created if missing - (!important!) Relationship types should be consistent and meaningful (e.g., IS_A, HAS, USES, IMPLEMENTS) - (!important!) Direction matters: "from" → "to" represents the relationship direction - (!important!) **Avoid redundant relationships** - check existing connections first </importantNotes> <whenToUseThisTool> - When establishing semantic connections between concepts - After creating entities that should be connected - When processing text that implies relationships - When building domain-specific ontologies - When migrating relational data into graph format - **Before querying graph paths** - ensure proper connectivity </whenToUseThisTool> <features> - Batch creation of multiple relationships in one operation - Automatic entity creation if referenced entities don't exist - Support for custom relationship types - Bidirectional relationship awareness - Confidence scoring and metadata support - Deduplication of identical relationships </features> <bestPractices> - Use consistent relationship types across your domain - Choose clear, unambiguous relationship names (IS_A, PART_OF, IMPLEMENTS) - Consider both directions when appropriate (if A USES B, does B DEPEND_ON A?) - Group related relationship creation for better performance - Use verb-like relationship types that read naturally - Document relationship semantics for complex domains </bestPractices> <parameters> - relations: Array of relationship objects, each containing: - from: Name of the source entity (string, required) - to: Name of the target entity (string, required) - relationType: Type/category of the relationship (string, required) </parameters> <examples> - Inheritance: {"relations": [{"from": "Dog", "to": "Animal", "relationType": "IS_A"}]} - Usage: {"relations": [{"from": "React", "to": "JavaScript", "relationType": "USES"}]} - Composition: {"relations": [{"from": "Car", "to": "Engine", "relationType": "HAS"}]} - Multiple: {"relations": [{"from": "Einstein", "to": "Relativity", "relationType": "DEVELOPED"}, {"from": "Relativity", "to": "Physics", "relationType": "PART_OF"}]} </examples>
<description> Add new observations to existing entities to continuously enrich their context, evidence, and understanding. **Essential for keeping your knowledge graph current and comprehensive.** Observations provide the factual foundation that supports entity existence and properties. </description> <importantNotes> - (!important!) **Entity must exist** - this tool only adds to existing entities - (!important!) Only new observations are added - duplicates are automatically filtered - (!important!) Observations are cumulative - they build the entity's knowledge base - (!important!) **Be specific and factual** - observations should be verifiable statements </importantNotes> <whenToUseThisTool> - When you discover new information about existing entities - After processing additional documents that mention known entities - When updating entity knowledge from new sources - When refining and expanding entity descriptions - **Before making knowledge-based decisions** - ensure entities have sufficient context - When correcting or expanding incomplete entity information </whenToUseThisTool> <features> - Batch addition of observations to multiple entities - Automatic duplicate filtering - no redundant observations - Supports rich textual observations with context - Maintains observation history and chronology - Integrates with document processing workflows - Enables incremental knowledge building </features> <bestPractices> - Keep observations factual and specific rather than general - Include source context when possible ("According to paper X...") - Use consistent terminology across observations - Add complementary observations that provide different perspectives - Include temporal information when relevant ("As of 2024...") - Group related observations by topic or source </bestPractices> <parameters> - observations: Array of observation addition objects, each containing: - entityName: Name of the existing entity to update (string, required) - contents: Array of new observation strings to add (string[], required) </parameters> <examples> - Scientific updates: {"observations": [{"entityName": "Quantum Computing", "contents": ["IBM achieved quantum advantage in 2024", "Shows promise for cryptography applications"]}]} - Person details: {"observations": [{"entityName": "Marie Curie", "contents": ["First woman to win Nobel Prize", "Won Nobel Prizes in two different sciences"]}]} - Technology evolution: {"observations": [{"entityName": "React", "contents": ["React 18 introduced concurrent features", "Widely adopted for enterprise applications"]}]} </examples>
<description> Perform sophisticated hybrid search that combines vector similarity with knowledge graph traversal for superior results. **The most powerful search tool in the system** - leverages both semantic similarity and structural relationships. Perfect for complex queries that benefit from both content matching and conceptual connections. </description> <importantNotes> - (!important!) **Hybrid approach is more powerful** than pure vector or graph search alone - (!important!) Graph enhancement finds related concepts even if not directly mentioned - (!important!) Results include similarity scores, graph boost, and hybrid rankings - (!important!) **Best results when knowledge graph is well-populated** with entities and relationships </importantNotes> <whenToUseThisTool> - When you need comprehensive search across documents and knowledge - For complex queries requiring conceptual understanding - When exploring relationships between concepts - **Before making decisions** - to gather all relevant information - When researching topics that span multiple domains - For discovery of implicit connections and patterns </whenToUseThisTool> <features> - Vector similarity search using sentence transformers - Knowledge graph traversal for conceptual enhancement - Hybrid scoring combining multiple relevance signals - Entity association highlighting - Configurable result limits and graph usage - Rich result metadata with multiple ranking scores </features> <bestPractices> - Use natural language queries rather than keywords - Enable graph enhancement for better conceptual coverage - Start with broader queries, then narrow down based on results - Review entity associations to understand why results were selected - Use appropriate limits based on your analysis needs - Combine with other tools for comprehensive knowledge exploration </bestPractices> <parameters> - query: Natural language search query (string, required) - limit: Maximum results to return, default 5 (number, optional) - useGraph: Enable knowledge graph enhancement, default true (boolean, optional) </parameters> <examples> - Conceptual search: {"query": "machine learning applications in healthcare", "limit": 10} - Technical research: {"query": "React performance optimization techniques", "useGraph": true} - Discovery mode: {"query": "Einstein's contributions to modern physics", "limit": 15} - Quick lookup: {"query": "quantum computing advantages", "limit": 3, "useGraph": false} </examples>
<description> Generate semantic vector embeddings for all entities in the knowledge graph to enable semantic search. **Essential for upgrading your knowledge graph to use semantic vector search instead of pattern matching.** This tool creates embeddings from entity names, types, and observations for powerful semantic discovery. </description> <importantNotes> - (!important!) **Processes all entities** in the knowledge graph at once - (!important!) **Enables semantic search** - required for vector-based entity discovery - (!important!) **Replaces pattern matching** with intelligent similarity search - (!important!) **Automatic for new entities** - only needed once for existing entities </importantNotes> <whenToUseThisTool> - **After importing existing entities** that don't have embeddings yet - When upgrading from pattern-based to semantic search - When entities have been created without automatic embedding generation - After significant updates to entity observations that require re-embedding - When setting up semantic search capabilities for the first time </whenToUseThisTool> <features> - Batch processing of all entities in the knowledge graph - Generates embeddings from entity names, types, and observations - Creates searchable vector representations using sentence transformers - Enables semantic similarity search across all entities - Automatic handling of embedding generation and storage - Progress reporting for large entity collections </features> <bestPractices> - Run once after importing entities from other systems - Use when transitioning from pattern-based to semantic search - Monitor progress output for large knowledge graphs - Ensure embedding model is properly initialized before running - Consider running after major entity data updates - Use as a one-time setup tool for existing knowledge graphs </bestPractices> <parameters> - No parameters required - processes all entities automatically </parameters> <examples> - Initial setup: {} (no parameters needed) - After import: {} (processes all existing entities) - Post-migration: {} (enables semantic search for imported data) </examples>
