Squashed 'vendor/ruvector/' content from commit b64c2172
git-subtree-dir: vendor/ruvector git-subtree-split: b64c21726f2bb37286d9ee36a7869fef60cc6900
This commit is contained in:
ruv
@@ -0,0 +1,584 @@
|
||||
/**
|
||||
* Graph Export Examples
|
||||
*
|
||||
* Demonstrates how to use the graph export module with various formats
|
||||
* and configurations.
|
||||
*/
|
||||
|
||||
import {
|
||||
buildGraphFromEntries,
|
||||
exportGraph,
|
||||
exportToGraphML,
|
||||
exportToGEXF,
|
||||
exportToNeo4j,
|
||||
exportToD3,
|
||||
exportToNetworkX,
|
||||
GraphMLStreamExporter,
|
||||
D3StreamExporter,
|
||||
type Graph,
|
||||
type GraphNode,
|
||||
type GraphEdge,
|
||||
type VectorEntry,
|
||||
type ExportOptions
|
||||
} from '../src/exporters.js';
|
||||
import { createWriteStream } from 'fs';
|
||||
import { writeFile } from 'fs/promises';
|
||||
|
||||
// ============================================================================
|
||||
// Example 1: Basic Graph Export to Multiple Formats
|
||||
// ============================================================================
|
||||
|
||||
export async function example1_basicExport() {
|
||||
console.log('\n=== Example 1: Basic Graph Export ===\n');
|
||||
|
||||
// Sample vector entries (embeddings from a document collection)
|
||||
const entries: VectorEntry[] = [
|
||||
{
|
||||
id: 'doc1',
|
||||
vector: [0.1, 0.2, 0.3, 0.4],
|
||||
metadata: { title: 'Introduction to AI', category: 'AI', year: 2023 }
|
||||
},
|
||||
{
|
||||
id: 'doc2',
|
||||
vector: [0.15, 0.25, 0.35, 0.42],
|
||||
metadata: { title: 'Machine Learning Basics', category: 'ML', year: 2023 }
|
||||
},
|
||||
{
|
||||
id: 'doc3',
|
||||
vector: [0.8, 0.1, 0.05, 0.05],
|
||||
metadata: { title: 'History of Rome', category: 'History', year: 2022 }
|
||||
},
|
||||
{
|
||||
id: 'doc4',
|
||||
vector: [0.12, 0.22, 0.32, 0.38],
|
||||
metadata: { title: 'Neural Networks', category: 'AI', year: 2024 }
|
||||
}
|
||||
];
|
||||
|
||||
// Build graph from vector entries
|
||||
const graph = buildGraphFromEntries(entries, {
|
||||
maxNeighbors: 2,
|
||||
threshold: 0.5,
|
||||
includeVectors: false,
|
||||
includeMetadata: true
|
||||
});
|
||||
|
||||
console.log(`Graph built: ${graph.nodes.length} nodes, ${graph.edges.length} edges\n`);
|
||||
|
||||
// Export to different formats
|
||||
const formats = ['graphml', 'gexf', 'neo4j', 'd3', 'networkx'] as const;
|
||||
|
||||
for (const format of formats) {
|
||||
const result = exportGraph(graph, format, {
|
||||
graphName: 'Document Similarity Network',
|
||||
graphDescription: 'Similarity network of document embeddings',
|
||||
includeMetadata: true
|
||||
});
|
||||
|
||||
console.log(`${format.toUpperCase()}:`);
|
||||
console.log(` Nodes: ${result.nodeCount}, Edges: ${result.edgeCount}`);
|
||||
|
||||
if (typeof result.data === 'string') {
|
||||
console.log(` Size: ${result.data.length} characters`);
|
||||
console.log(` Preview: ${result.data.substring(0, 100)}...\n`);
|
||||
} else {
|
||||
console.log(` Type: JSON object`);
|
||||
console.log(` Preview: ${JSON.stringify(result.data).substring(0, 100)}...\n`);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
// ============================================================================
|
||||
// Example 2: Export to GraphML with Full Configuration
|
||||
// ============================================================================
|
||||
|
||||
export async function example2_graphMLExport() {
|
||||
console.log('\n=== Example 2: GraphML Export ===\n');
|
||||
|
||||
const entries: VectorEntry[] = [
|
||||
{
|
||||
id: 'vec1',
|
||||
vector: [1.0, 0.0, 0.0],
|
||||
metadata: { label: 'Vector 1', type: 'test', score: 0.95 }
|
||||
},
|
||||
{
|
||||
id: 'vec2',
|
||||
vector: [0.9, 0.1, 0.0],
|
||||
metadata: { label: 'Vector 2', type: 'test', score: 0.87 }
|
||||
},
|
||||
{
|
||||
id: 'vec3',
|
||||
vector: [0.0, 1.0, 0.0],
|
||||
metadata: { label: 'Vector 3', type: 'control', score: 0.92 }
|
||||
}
|
||||
];
|
||||
|
||||
const graph = buildGraphFromEntries(entries, {
|
||||
maxNeighbors: 2,
|
||||
threshold: 0.0,
|
||||
includeVectors: true, // Include vectors in export
|
||||
includeMetadata: true
|
||||
});
|
||||
|
||||
const graphml = exportToGraphML(graph, {
|
||||
graphName: 'Test Vectors',
|
||||
includeVectors: true
|
||||
});
|
||||
|
||||
console.log('GraphML Export:');
|
||||
console.log(graphml);
|
||||
|
||||
// Save to file
|
||||
await writeFile('examples/output/graph.graphml', graphml);
|
||||
console.log('\nSaved to: examples/output/graph.graphml');
|
||||
}
|
||||
|
||||
// ============================================================================
|
||||
// Example 3: Export to GEXF for Gephi Visualization
|
||||
// ============================================================================
|
||||
|
||||
export async function example3_gephiExport() {
|
||||
console.log('\n=== Example 3: GEXF Export for Gephi ===\n');
|
||||
|
||||
// Simulate a larger network
|
||||
const entries: VectorEntry[] = [];
|
||||
for (let i = 0; i < 20; i++) {
|
||||
entries.push({
|
||||
id: `node${i}`,
|
||||
vector: Array(128).fill(0).map(() => Math.random()),
|
||||
metadata: {
|
||||
label: `Node ${i}`,
|
||||
cluster: Math.floor(i / 5),
|
||||
importance: Math.random()
|
||||
}
|
||||
});
|
||||
}
|
||||
|
||||
const graph = buildGraphFromEntries(entries, {
|
||||
maxNeighbors: 3,
|
||||
threshold: 0.7,
|
||||
includeMetadata: true
|
||||
});
|
||||
|
||||
const gexf = exportToGEXF(graph, {
|
||||
graphName: 'Large Network',
|
||||
graphDescription: 'Network with 20 nodes and cluster information'
|
||||
});
|
||||
|
||||
await writeFile('examples/output/network.gexf', gexf);
|
||||
console.log('GEXF file created: examples/output/network.gexf');
|
||||
console.log('Import this file into Gephi for visualization!');
|
||||
}
|
||||
|
||||
// ============================================================================
|
||||
// Example 4: Export to Neo4j and Execute Queries
|
||||
// ============================================================================
|
||||
|
||||
export async function example4_neo4jExport() {
|
||||
console.log('\n=== Example 4: Neo4j Export ===\n');
|
||||
|
||||
const entries: VectorEntry[] = [
|
||||
{
|
||||
id: 'person1',
|
||||
vector: [0.5, 0.5],
|
||||
metadata: { name: 'Alice', role: 'Engineer', experience: 5 }
|
||||
},
|
||||
{
|
||||
id: 'person2',
|
||||
vector: [0.52, 0.48],
|
||||
metadata: { name: 'Bob', role: 'Engineer', experience: 3 }
|
||||
},
|
||||
{
|
||||
id: 'person3',
|
||||
vector: [0.1, 0.9],
|
||||
metadata: { name: 'Charlie', role: 'Manager', experience: 10 }
|
||||
}
|
||||
];
|
||||
|
||||
const graph = buildGraphFromEntries(entries, {
|
||||
maxNeighbors: 2,
|
||||
threshold: 0.5,
|
||||
includeMetadata: true
|
||||
});
|
||||
|
||||
const cypher = exportToNeo4j(graph, {
|
||||
includeMetadata: true
|
||||
});
|
||||
|
||||
console.log('Neo4j Cypher Queries:');
|
||||
console.log(cypher);
|
||||
|
||||
await writeFile('examples/output/import.cypher', cypher);
|
||||
console.log('\nSaved to: examples/output/import.cypher');
|
||||
console.log('\nTo import into Neo4j:');
|
||||
console.log(' 1. Open Neo4j Browser');
|
||||
console.log(' 2. Copy and paste the Cypher queries');
|
||||
console.log(' 3. Execute to create the graph');
|
||||
}
|
||||
|
||||
// ============================================================================
|
||||
// Example 5: Export to D3.js for Web Visualization
|
||||
// ============================================================================
|
||||
|
||||
export async function example5_d3Export() {
|
||||
console.log('\n=== Example 5: D3.js Export ===\n');
|
||||
|
||||
const entries: VectorEntry[] = [
|
||||
{
|
||||
id: 'central',
|
||||
vector: [0.5, 0.5],
|
||||
metadata: { name: 'Central Node', size: 20, color: '#ff0000' }
|
||||
},
|
||||
{
|
||||
id: 'node1',
|
||||
vector: [0.6, 0.5],
|
||||
metadata: { name: 'Node 1', size: 10, color: '#00ff00' }
|
||||
},
|
||||
{
|
||||
id: 'node2',
|
||||
vector: [0.4, 0.5],
|
||||
metadata: { name: 'Node 2', size: 10, color: '#0000ff' }
|
||||
},
|
||||
{
|
||||
id: 'node3',
|
||||
vector: [0.5, 0.6],
|
||||
metadata: { name: 'Node 3', size: 10, color: '#ffff00' }
|
||||
}
|
||||
];
|
||||
|
||||
const graph = buildGraphFromEntries(entries, {
|
||||
maxNeighbors: 3,
|
||||
threshold: 0.0,
|
||||
includeMetadata: true
|
||||
});
|
||||
|
||||
const d3Data = exportToD3(graph, {
|
||||
includeMetadata: true
|
||||
});
|
||||
|
||||
console.log('D3.js Data:');
|
||||
console.log(JSON.stringify(d3Data, null, 2));
|
||||
|
||||
await writeFile('examples/output/d3-graph.json', JSON.stringify(d3Data, null, 2));
|
||||
console.log('\nSaved to: examples/output/d3-graph.json');
|
||||
|
||||
// Generate simple HTML visualization
|
||||
const html = `
|
||||
<!DOCTYPE html>
|
||||
<html>
|
||||
<head>
|
||||
<title>D3.js Force Graph</title>
|
||||
<script src="https://d3js.org/d3.v7.min.js"></script>
|
||||
<style>
|
||||
body { margin: 0; font-family: Arial, sans-serif; }
|
||||
svg { border: 1px solid #ccc; }
|
||||
.links line { stroke: #999; stroke-opacity: 0.6; }
|
||||
.nodes circle { stroke: #fff; stroke-width: 1.5px; }
|
||||
.labels { font-size: 10px; pointer-events: none; }
|
||||
</style>
|
||||
</head>
|
||||
<body>
|
||||
<svg width="800" height="600"></svg>
|
||||
<script>
|
||||
const graphData = ${JSON.stringify(d3Data)};
|
||||
|
||||
const svg = d3.select("svg"),
|
||||
width = +svg.attr("width"),
|
||||
height = +svg.attr("height");
|
||||
|
||||
const simulation = d3.forceSimulation(graphData.nodes)
|
||||
.force("link", d3.forceLink(graphData.links).id(d => d.id).distance(100))
|
||||
.force("charge", d3.forceManyBody().strength(-300))
|
||||
.force("center", d3.forceCenter(width / 2, height / 2));
|
||||
|
||||
const link = svg.append("g")
|
||||
.attr("class", "links")
|
||||
.selectAll("line")
|
||||
.data(graphData.links)
|
||||
.enter().append("line")
|
||||
.attr("stroke-width", d => Math.sqrt(d.value) * 2);
|
||||
|
||||
const node = svg.append("g")
|
||||
.attr("class", "nodes")
|
||||
.selectAll("circle")
|
||||
.data(graphData.nodes)
|
||||
.enter().append("circle")
|
||||
.attr("r", d => d.size || 5)
|
||||
.attr("fill", d => d.color || "#69b3a2")
|
||||
.call(d3.drag()
|
||||
.on("start", dragstarted)
|
||||
.on("drag", dragged)
|
||||
.on("end", dragended));
|
||||
|
||||
const label = svg.append("g")
|
||||
.attr("class", "labels")
|
||||
.selectAll("text")
|
||||
.data(graphData.nodes)
|
||||
.enter().append("text")
|
||||
.text(d => d.name)
|
||||
.attr("dx", 12)
|
||||
.attr("dy", 4);
|
||||
|
||||
simulation.on("tick", () => {
|
||||
link.attr("x1", d => d.source.x)
|
||||
.attr("y1", d => d.source.y)
|
||||
.attr("x2", d => d.target.x)
|
||||
.attr("y2", d => d.target.y);
|
||||
node.attr("cx", d => d.x)
|
||||
.attr("cy", d => d.y);
|
||||
label.attr("x", d => d.x)
|
||||
.attr("y", d => d.y);
|
||||
});
|
||||
|
||||
function dragstarted(event, d) {
|
||||
if (!event.active) simulation.alphaTarget(0.3).restart();
|
||||
d.fx = d.x;
|
||||
d.fy = d.y;
|
||||
}
|
||||
|
||||
function dragged(event, d) {
|
||||
d.fx = event.x;
|
||||
d.fy = event.y;
|
||||
}
|
||||
|
||||
function dragended(event, d) {
|
||||
if (!event.active) simulation.alphaTarget(0);
|
||||
d.fx = null;
|
||||
d.fy = null;
|
||||
}
|
||||
</script>
|
||||
</body>
|
||||
</html>`;
|
||||
|
||||
await writeFile('examples/output/d3-visualization.html', html);
|
||||
console.log('Created HTML visualization: examples/output/d3-visualization.html');
|
||||
console.log('Open this file in a web browser to see the interactive graph!');
|
||||
}
|
||||
|
||||
// ============================================================================
|
||||
// Example 6: Export to NetworkX for Python Analysis
|
||||
// ============================================================================
|
||||
|
||||
export async function example6_networkXExport() {
|
||||
console.log('\n=== Example 6: NetworkX Export ===\n');
|
||||
|
||||
const entries: VectorEntry[] = [];
|
||||
for (let i = 0; i < 10; i++) {
|
||||
entries.push({
|
||||
id: `node_${i}`,
|
||||
vector: Array(64).fill(0).map(() => Math.random()),
|
||||
metadata: { degree: i, centrality: Math.random() }
|
||||
});
|
||||
}
|
||||
|
||||
const graph = buildGraphFromEntries(entries, {
|
||||
maxNeighbors: 3,
|
||||
threshold: 0.6
|
||||
});
|
||||
|
||||
const nxData = exportToNetworkX(graph, {
|
||||
includeMetadata: true
|
||||
});
|
||||
|
||||
await writeFile('examples/output/networkx-graph.json', JSON.stringify(nxData, null, 2));
|
||||
console.log('NetworkX JSON saved to: examples/output/networkx-graph.json');
|
||||
|
||||
// Generate Python script
|
||||
const pythonScript = `
|
||||
import json
|
||||
import networkx as nx
|
||||
import matplotlib.pyplot as plt
|
||||
|
||||
# Load the graph
|
||||
with open('networkx-graph.json', 'r') as f:
|
||||
data = json.load(f)
|
||||
|
||||
G = nx.node_link_graph(data)
|
||||
|
||||
# Calculate centrality measures
|
||||
degree_centrality = nx.degree_centrality(G)
|
||||
betweenness_centrality = nx.betweenness_centrality(G)
|
||||
|
||||
print(f"Graph has {G.number_of_nodes()} nodes and {G.number_of_edges()} edges")
|
||||
print(f"\\nTop 5 nodes by degree centrality:")
|
||||
sorted_nodes = sorted(degree_centrality.items(), key=lambda x: x[1], reverse=True)[:5]
|
||||
for node, centrality in sorted_nodes:
|
||||
print(f" {node}: {centrality:.4f}")
|
||||
|
||||
# Visualize
|
||||
plt.figure(figsize=(12, 8))
|
||||
pos = nx.spring_layout(G, k=0.5, iterations=50)
|
||||
nx.draw(G, pos,
|
||||
node_color=[degree_centrality[node] for node in G.nodes()],
|
||||
node_size=[v * 1000 for v in degree_centrality.values()],
|
||||
cmap=plt.cm.plasma,
|
||||
with_labels=True,
|
||||
font_size=8,
|
||||
font_weight='bold',
|
||||
edge_color='gray',
|
||||
alpha=0.7)
|
||||
plt.title('Network Graph Visualization')
|
||||
plt.colorbar(plt.cm.ScalarMappable(cmap=plt.cm.plasma), label='Degree Centrality')
|
||||
plt.savefig('network-visualization.png', dpi=300, bbox_inches='tight')
|
||||
print("\\nVisualization saved to: network-visualization.png")
|
||||
`;
|
||||
|
||||
await writeFile('examples/output/analyze_network.py', pythonScript);
|
||||
console.log('Python analysis script saved to: examples/output/analyze_network.py');
|
||||
console.log('\nTo analyze in Python:');
|
||||
console.log(' cd examples/output');
|
||||
console.log(' pip install networkx matplotlib');
|
||||
console.log(' python analyze_network.py');
|
||||
}
|
||||
|
||||
// ============================================================================
|
||||
// Example 7: Streaming Export for Large Graphs
|
||||
// ============================================================================
|
||||
|
||||
export async function example7_streamingExport() {
|
||||
console.log('\n=== Example 7: Streaming Export ===\n');
|
||||
|
||||
// Simulate a large graph that doesn't fit in memory
|
||||
console.log('Creating streaming GraphML export...');
|
||||
|
||||
const stream = createWriteStream('examples/output/large-graph.graphml');
|
||||
const exporter = new GraphMLStreamExporter(stream, {
|
||||
graphName: 'Large Streaming Graph'
|
||||
});
|
||||
|
||||
await exporter.start();
|
||||
|
||||
// Add nodes in batches
|
||||
for (let i = 0; i < 1000; i++) {
|
||||
const node: GraphNode = {
|
||||
id: `node${i}`,
|
||||
label: `Node ${i}`,
|
||||
attributes: {
|
||||
batch: Math.floor(i / 100),
|
||||
value: Math.random()
|
||||
}
|
||||
};
|
||||
await exporter.addNode(node);
|
||||
|
||||
if (i % 100 === 0) {
|
||||
console.log(` Added ${i} nodes...`);
|
||||
}
|
||||
}
|
||||
|
||||
console.log(' Added 1000 nodes');
|
||||
|
||||
// Add edges
|
||||
let edgeCount = 0;
|
||||
for (let i = 0; i < 1000; i++) {
|
||||
for (let j = i + 1; j < Math.min(i + 5, 1000); j++) {
|
||||
const edge: GraphEdge = {
|
||||
source: `node${i}`,
|
||||
target: `node${j}`,
|
||||
weight: Math.random()
|
||||
};
|
||||
await exporter.addEdge(edge);
|
||||
edgeCount++;
|
||||
}
|
||||
}
|
||||
|
||||
console.log(` Added ${edgeCount} edges`);
|
||||
|
||||
await exporter.end();
|
||||
stream.close();
|
||||
|
||||
console.log('\nStreaming export completed: examples/output/large-graph.graphml');
|
||||
console.log('This approach works for graphs with millions of nodes!');
|
||||
}
|
||||
|
||||
// ============================================================================
|
||||
// Example 8: Custom Graph Construction
|
||||
// ============================================================================
|
||||
|
||||
export async function example8_customGraph() {
|
||||
console.log('\n=== Example 8: Custom Graph Construction ===\n');
|
||||
|
||||
// Build a custom graph structure manually
|
||||
const graph: Graph = {
|
||||
nodes: [
|
||||
{ id: 'A', label: 'Root', attributes: { level: 0, type: 'root' } },
|
||||
{ id: 'B', label: 'Child 1', attributes: { level: 1, type: 'child' } },
|
||||
{ id: 'C', label: 'Child 2', attributes: { level: 1, type: 'child' } },
|
||||
{ id: 'D', label: 'Leaf 1', attributes: { level: 2, type: 'leaf' } },
|
||||
{ id: 'E', label: 'Leaf 2', attributes: { level: 2, type: 'leaf' } }
|
||||
],
|
||||
edges: [
|
||||
{ source: 'A', target: 'B', weight: 1.0, type: 'parent-child' },
|
||||
{ source: 'A', target: 'C', weight: 1.0, type: 'parent-child' },
|
||||
{ source: 'B', target: 'D', weight: 0.8, type: 'parent-child' },
|
||||
{ source: 'C', target: 'E', weight: 0.9, type: 'parent-child' },
|
||||
{ source: 'B', target: 'C', weight: 0.5, type: 'sibling' }
|
||||
],
|
||||
metadata: {
|
||||
description: 'Hierarchical tree structure',
|
||||
created: new Date().toISOString()
|
||||
}
|
||||
};
|
||||
|
||||
// Export to multiple formats
|
||||
const graphML = exportToGraphML(graph);
|
||||
const d3Data = exportToD3(graph);
|
||||
const neo4j = exportToNeo4j(graph);
|
||||
|
||||
await writeFile('examples/output/custom-graph.graphml', graphML);
|
||||
await writeFile('examples/output/custom-graph-d3.json', JSON.stringify(d3Data, null, 2));
|
||||
await writeFile('examples/output/custom-graph.cypher', neo4j);
|
||||
|
||||
console.log('Custom graph exported to:');
|
||||
console.log(' - examples/output/custom-graph.graphml');
|
||||
console.log(' - examples/output/custom-graph-d3.json');
|
||||
console.log(' - examples/output/custom-graph.cypher');
|
||||
}
|
||||
|
||||
// ============================================================================
|
||||
// Run All Examples
|
||||
// ============================================================================
|
||||
|
||||
export async function runAllExamples() {
|
||||
console.log('╔═══════════════════════════════════════════════════════╗');
|
||||
console.log('║ ruvector Graph Export Examples ║');
|
||||
console.log('╚═══════════════════════════════════════════════════════╝');
|
||||
|
||||
// Create output directory
|
||||
const fs = await import('fs/promises');
|
||||
try {
|
||||
await fs.mkdir('examples/output', { recursive: true });
|
||||
} catch (e) {
|
||||
// Directory already exists
|
||||
}
|
||||
|
||||
try {
|
||||
await example1_basicExport();
|
||||
await example2_graphMLExport();
|
||||
await example3_gephiExport();
|
||||
await example4_neo4jExport();
|
||||
await example5_d3Export();
|
||||
await example6_networkXExport();
|
||||
await example7_streamingExport();
|
||||
await example8_customGraph();
|
||||
|
||||
console.log('\n✅ All examples completed successfully!');
|
||||
console.log('\nGenerated files in examples/output/:');
|
||||
console.log(' - graph.graphml (GraphML format)');
|
||||
console.log(' - network.gexf (Gephi format)');
|
||||
console.log(' - import.cypher (Neo4j queries)');
|
||||
console.log(' - d3-graph.json (D3.js data)');
|
||||
console.log(' - d3-visualization.html (Interactive visualization)');
|
||||
console.log(' - networkx-graph.json (NetworkX format)');
|
||||
console.log(' - analyze_network.py (Python analysis script)');
|
||||
console.log(' - large-graph.graphml (Streaming export demo)');
|
||||
console.log(' - custom-graph.* (Custom graph exports)');
|
||||
} catch (error) {
|
||||
console.error('\n❌ Error running examples:', error);
|
||||
throw error;
|
||||
}
|
||||
}
|
||||
|
||||
// Run if executed directly
|
||||
if (import.meta.url === `file://${process.argv[1]}`) {
|
||||
runAllExamples().catch(console.error);
|
||||
}
|
||||
Reference in New Issue
Block a user