Graph Search & Logic Mesh

# Enable entity-relationship extraction
memvid put memory.mv2 --input documents/ --logic-mesh

# Enrich existing documents with graph extraction
memvid enrich memory.mv2 --engine groq

# Show all extracted entities
memvid follow entities memory.mv2

# Filter by entity type
memvid follow entities memory.mv2 --kind person
memvid follow entities memory.mv2 --kind company
memvid follow entities memory.mv2 --kind product

# Search entities by name
memvid follow entities memory.mv2 --query "John"

# Limit results
memvid follow entities memory.mv2 --limit 20

# JSON output
memvid follow entities memory.mv2 --json

Entities (87 total)

People:
  - John Smith (34 relationships)
  - Jane Doe (28 relationships)
  - Sarah Chen (19 relationships)

Companies:
  - Acme Corp (45 relationships)
  - StartupXYZ (12 relationships)
  - TechGiant Inc (8 relationships)

Products:
  - Project Alpha (15 relationships)
  - Platform v2 (9 relationships)

# Find what John Smith is connected to
memvid follow traverse memory.mv2 --start "John Smith"

# Follow specific relationship type
memvid follow traverse memory.mv2 --start "John Smith" --link works_at

# Control traversal depth (default: 2)
memvid follow traverse memory.mv2 --start "Acme Corp" --hops 3

# Direction: outgoing, incoming, or both
memvid follow traverse memory.mv2 --start "Jane Doe" --direction incoming

Traversal from: John Smith (depth: 2)

Direct relationships (hop 1):
  ──[works_at]──▶ Acme Corp
  ──[reports_to]──▶ Jane Doe
  ──[leads]──▶ Project Alpha
  ──[expertise]──▶ Rust, Python

Extended relationships (hop 2):
  Acme Corp ──[acquired]──▶ StartupXYZ
  Acme Corp ──[headquartered_in]──▶ San Francisco
  Jane Doe ──[reports_to]──▶ CEO Board
  Project Alpha ──[uses]──▶ Platform v2

memvid follow stats memory.mv2

Logic Mesh Statistics

Entities: 87
  - person: 34
  - company: 18
  - product: 15
  - concept: 20

Relationships: 423
  - works_at: 45
  - reports_to: 32
  - founded: 12
  - acquired: 8
  - uses: 56
  - expertise: 89
  - other: 181

Graph density: 4.86 edges/node
Connected components: 3
Largest component: 72 entities

# Find where John works
memvid find memory.mv2 --graph "John Smith:works_at:?"

# Find who works at Acme
memvid find memory.mv2 --graph "?:works_at:Acme Corp"

# Find all relationships between two entities
memvid find memory.mv2 --graph "John Smith:?:Acme Corp"

# Find revenue info, but only from Acme-related documents
memvid find memory.mv2 --query "revenue" --graph "?:works_at:Acme Corp"

# Find meeting notes involving John
memvid find memory.mv2 --query "meeting notes" --graph "John Smith:?:?"

# Semantic search within a relationship context
memvid find memory.mv2 --query "Q4 results" --hybrid --graph "?:works_at:Acme"

# Find similar documents to what relates to a topic
memvid find memory.mv2 --query "machine learning" --hybrid --graph "?:expertise:ML"

from memvid import use

mem = use('basic', 'memory.mv2')

# Enable logic mesh during put
mem.put(
    text="John Smith works at Acme Corp as a Senior Engineer.",
    logic_mesh=True
)

# List entities
entities = mem.get_entities()
for entity in entities:
    print(f"{entity.name} ({entity.kind}): {entity.relationship_count} relationships")

# Traverse from an entity
graph = mem.traverse(
    start="John Smith",
    link="works_at",
    hops=2,
    direction="outgoing"
)

for node in graph.nodes:
    print(f"{node.name}: {node.relationships}")

# Graph-filtered search
results = mem.find(
    "quarterly report",
    graph_pattern="?:works_at:Acme Corp"
)

# Hybrid search
results = mem.find(
    "machine learning",
    hybrid=True,
    graph_pattern="?:expertise:ML"
)

import { use } from '@anthropics/memvid'

const mem = await use('basic', 'memory.mv2')

// Enable logic mesh during put
await mem.put({
  content: "John Smith works at Acme Corp as a Senior Engineer.",
  logicMesh: true
})

// List entities
const entities = await mem.getEntities()
for (const entity of entities) {
  console.log(`${entity.name} (${entity.kind}): ${entity.relationshipCount} relationships`)
}

// Traverse from an entity
const graph = await mem.traverse({
  start: "John Smith",
  link: "works_at",
  hops: 2,
  direction: "outgoing"
})

// Graph-filtered search
const results = await mem.find("quarterly report", {
  graphPattern: "?:works_at:Acme Corp"
})

# Who do people at Acme report to? (2 hops)
memvid follow traverse memory.mv2 --start "Acme Corp" --link "works_at,reports_to" --hops 2

# Find the CEO through org chart
memvid follow traverse memory.mv2 --start "John Smith" --link "reports_to" --hops 5

# Find people who work at Acme AND have ML expertise
memvid find memory.mv2 --graph "?:works_at:Acme Corp" --graph "?:expertise:ML"

# Find all employees except those reporting to Jane
memvid follow entities memory.mv2 --kind person --exclude-pattern "?:reports_to:Jane"

memvid export memory.mv2 --format ntriples --out graph.nt

<John_Smith> <works_at> <Acme_Corp> .
<John_Smith> <reports_to> <Jane_Doe> .
<John_Smith> <expertise> "Rust" .
<Acme_Corp> <acquired> <StartupXYZ> .

memvid export memory.mv2 --format json --out graph.json

{
  "nodes": [
    {"id": "John_Smith", "kind": "person", "properties": {...}},
    {"id": "Acme_Corp", "kind": "company", "properties": {...}}
  ],
  "edges": [
    {"source": "John_Smith", "target": "Acme_Corp", "relation": "works_at"},
    {"source": "John_Smith", "target": "Jane_Doe", "relation": "reports_to"}
  ]
}

memvid export memory.mv2 --format csv --out graph.csv

subject,predicate,object,confidence,source_frame
John_Smith,works_at,Acme_Corp,0.94,frame_001
John_Smith,reports_to,Jane_Doe,0.91,frame_001
Acme_Corp,acquired,StartupXYZ,0.88,frame_045

# Ingest org documents
memvid put org.mv2 --input hr_docs/ --logic-mesh

# Find everyone's reporting structure
memvid follow traverse org.mv2 --start "CEO" --link "manages" --hops 5 --direction outgoing

# Who reports to a specific manager?
memvid find org.mv2 --graph "?:reports_to:Sarah Chen"

# Ingest papers
memvid put research.mv2 --input papers/ --logic-mesh

# Find papers citing a specific work
memvid find research.mv2 --graph "?:cites:Attention Is All You Need"

# Find concepts related to transformers
memvid follow traverse research.mv2 --start "Transformers" --hops 2

# Find all contacts at a company
memvid find customers.mv2 --graph "?:works_at:BigCorp Inc"

# Find decision makers
memvid find customers.mv2 --graph "?:role:VP" --graph "?:works_at:BigCorp Inc"

# Find what depends on a module
memvid find codebase.mv2 --graph "?:imports:auth_module"

# Find all API endpoints
memvid follow entities codebase.mv2 --kind endpoint

# Build graph index for faster traversals
memvid doctor memory.mv2 --rebuild-logic-mesh

# Default (recommended)
--hops 2

# Use sparingly
--hops 3 or higher

# Good: Graph filter narrows results first
memvid find memory.mv2 --graph "?:works_at:Acme" --query "report"

# Less efficient: Broad text search then filter
memvid find memory.mv2 --query "report" | grep Acme