zrald1/dist/types/graph.js

Advanced Graph RAG MCP Server with file location identification, graph processing, and result summarization capabilities

import { z } from 'zod';
// Core Graph Types
export const NodeSchema = z.object({
    id: z.string(),
    type: z.enum(['entity', 'concept', 'document', 'chunk', 'summary', 'file']),
    label: z.string(),
    properties: z.record(z.any()),
    embedding: z.array(z.number()).optional(),
    metadata: z.record(z.any()).optional(),
    created_at: z.date().default(() => new Date()),
    updated_at: z.date().default(() => new Date())
});
export const RelationshipSchema = z.object({
    id: z.string(),
    source_id: z.string(),
    target_id: z.string(),
    type: z.string(),
    properties: z.record(z.any()),
    weight: z.number().default(1.0),
    confidence: z.number().min(0).max(1).default(1.0),
    metadata: z.record(z.any()).optional(),
    created_at: z.date().default(() => new Date())
});
export const ChunkSchema = z.object({
    id: z.string(),
    content: z.string(),
    document_id: z.string(),
    position: z.number(),
    embedding: z.array(z.number()).optional(),
    entities: z.array(z.string()).default([]),
    metadata: z.record(z.any()).optional()
});
// File Processing Types
export const FileSchema = z.object({
    id: z.string(),
    path: z.string(),
    name: z.string(),
    extension: z.string(),
    size: z.number(),
    content: z.string().optional(),
    metadata: z.record(z.any()).optional(),
    created_at: z.date().default(() => new Date()),
    updated_at: z.date().default(() => new Date())
});
// Graph Structure Types
export const PassageGraphSchema = z.object({
    nodes: z.array(NodeSchema),
    relationships: z.array(RelationshipSchema),
    type: z.literal('passage')
});
export const TreesGraphSchema = z.object({
    nodes: z.array(NodeSchema),
    relationships: z.array(RelationshipSchema),
    root_nodes: z.array(z.string()),
    levels: z.number(),
    type: z.literal('trees')
});
export const KnowledgeGraphSchema = z.object({
    nodes: z.array(NodeSchema),
    relationships: z.array(RelationshipSchema),
    entities: z.array(z.string()),
    concepts: z.array(z.string()),
    type: z.literal('knowledge')
});
export const DAGSchema = z.object({
    nodes: z.array(NodeSchema),
    relationships: z.array(RelationshipSchema),
    entry_points: z.array(z.string()),
    exit_points: z.array(z.string()),
    type: z.literal('dag')
});
// Operator Types
export const OperatorResultSchema = z.object({
    nodes: z.array(NodeSchema),
    relationships: z.array(RelationshipSchema),
    chunks: z.array(ChunkSchema).optional(),
    files: z.array(FileSchema).optional(),
    scores: z.record(z.number()).optional(),
    metadata: z.record(z.any()).optional()
});
export const VDBOperatorConfigSchema = z.object({
    query_embedding: z.array(z.number()),
    top_k: z.number().default(10),
    similarity_threshold: z.number().min(0).max(1).default(0.7),
    node_types: z.array(z.string()).optional()
});
export const PPROperatorConfigSchema = z.object({
    seed_nodes: z.array(z.string()),
    damping_factor: z.number().min(0).max(1).default(0.85),
    max_iterations: z.number().default(100),
    tolerance: z.number().default(1e-6),
    personalization: z.record(z.number()).optional()
});
export const OneHopOperatorConfigSchema = z.object({
    source_nodes: z.array(z.string()),
    relationship_types: z.array(z.string()).optional(),
    direction: z.enum(['incoming', 'outgoing', 'both']).default('both'),
    max_depth: z.number().default(1)
});
export const KHopPathOperatorConfigSchema = z.object({
    source_nodes: z.array(z.string()),
    target_nodes: z.array(z.string()),
    max_hops: z.number().default(3),
    relationship_types: z.array(z.string()).optional(),
    path_limit: z.number().default(10)
});
// Additional Operator Configs
export const AggregatorOperatorConfigSchema = z.object({
    source_nodes: z.array(z.string()),
    aggregation_method: z.enum(['sum', 'average', 'max', 'weighted']).default('weighted'),
    relationship_weights: z.record(z.number()).optional(),
    normalize_scores: z.boolean().default(true)
});
export const FromRelOperatorConfigSchema = z.object({
    relationship_ids: z.array(z.string()),
    include_context: z.boolean().default(true),
    context_window: z.number().default(2)
});
export const OccurrenceOperatorConfigSchema = z.object({
    entities: z.array(z.string()),
    co_occurrence_window: z.number().default(50),
    min_frequency: z.number().default(1),
    include_positions: z.boolean().default(false)
});
export const SteinerOperatorConfigSchema = z.object({
    terminal_nodes: z.array(z.string()),
    edge_weights: z.record(z.number()).optional(),
    algorithm: z.enum(['approximation', 'exact']).default('approximation'),
    max_tree_size: z.number().default(100)
});
// File Processing Operator Configs
export const FileLocationOperatorConfigSchema = z.object({
    query: z.string(),
    file_types: z.array(z.string()).optional(),
    search_paths: z.array(z.string()).optional(),
    recursive: z.boolean().default(true),
    max_results: z.number().default(50)
});
// Execution Pattern Types
export const ExecutionPatternSchema = z.enum(['sequential', 'parallel', 'adaptive']);
export const OperatorChainSchema = z.object({
    operators: z.array(z.object({
        type: z.string(),
        config: z.record(z.any()),
        dependencies: z.array(z.string()).default([])
    })),
    execution_pattern: ExecutionPatternSchema,
    fusion_strategy: z.enum(['union', 'intersection', 'weighted_average']).default('union')
});
// Query and Planning Types
export const QueryPlanSchema = z.object({
    id: z.string(),
    query: z.string(),
    intent: z.enum(['factual', 'analytical', 'exploratory', 'comparative', 'file_search']),
    operator_chain: OperatorChainSchema,
    estimated_cost: z.number().optional(),
    priority: z.enum(['low', 'medium', 'high', 'critical']).default('medium')
});
//# sourceMappingURL=graph.js.map