How to Combine Graph Memory with Search MCP for Agents

from neo4j import GraphDatabase
import os

NEO4J_URI = os.environ.get('NEO4J_URI', 'bolt://localhost:7687')
NEO4J_USER = os.environ.get('NEO4J_USER', 'neo4j')
NEO4J_PASS = os.environ.get('NEO4J_PASS', 'password')

driver = GraphDatabase.driver(NEO4J_URI, auth=(NEO4J_USER, NEO4J_PASS))

def init_schema():
    with driver.session() as s:
        s.run('CREATE CONSTRAINT IF NOT EXISTS FOR (e:Entity) REQUIRE e.name IS UNIQUE')
        s.run('CREATE CONSTRAINT IF NOT EXISTS FOR (s:SearchResult) REQUIRE s.url IS UNIQUE')
        s.run('CREATE INDEX IF NOT EXISTS FOR (s:SearchResult) ON (s.query)')
    print('Graph schema initialized')

init_schema()

import requests
from datetime import datetime, timedelta

H = {'x-api-key': os.environ['SCAVIO_API_KEY'], 'Content-Type': 'application/json'}
CACHE_TTL_HOURS = 24

def search_with_memory(query):
    # Check graph memory first
    with driver.session() as s:
        cached = s.run(
            'MATCH (sr:SearchResult {query: $q}) '
            'WHERE sr.fetched_at > datetime() - duration({hours: $ttl}) '
            'RETURN sr.title AS title, sr.url AS url, sr.snippet AS snippet '
            'ORDER BY sr.position LIMIT 10',
            q=query, ttl=CACHE_TTL_HOURS
        ).data()
    if cached:
        print(f'Memory hit: {len(cached)} results for "{query}"')
        return cached

    # Cache miss: search live
    data = requests.post('https://api.scavio.dev/api/v1/search',
        headers=H, json={'query': query, 'country_code': 'us'}).json()
    results = data.get('organic_results', [])

    # Store in graph
    with driver.session() as s:
        for r in results:
            s.run(
                'MERGE (sr:SearchResult {url: $url}) '
                'SET sr.title = $title, sr.snippet = $snippet, '
                'sr.query = $query, sr.position = $pos, sr.fetched_at = datetime()',
                url=r.get('link', ''), title=r.get('title', ''),
                snippet=r.get('snippet', ''), query=query, pos=r.get('position', 0)
            )
    print(f'Live search: {len(results)} results stored for "{query}"')
    return results

import re

def extract_entities(text, entity_types=None):
    # Simple pattern-based extraction (replace with NER model for production)
    entities = set()
    # Capitalized multi-word phrases (likely proper nouns)
    for match in re.findall(r'\b([A-Z][a-z]+(?: [A-Z][a-z]+)+)\b', text):
        entities.add(match)
    return list(entities)

def store_entities_from_results(query, results):
    with driver.session() as s:
        topic = s.run(
            'MERGE (e:Entity {name: $name}) '
            'SET e.type = "topic", e.last_searched = datetime() '
            'RETURN e', name=query
        ).single()

        for r in results:
            text = f"{r.get('title', '')} {r.get('snippet', '')}"
            entities = extract_entities(text)
            for ent in entities:
                s.run(
                    'MERGE (e:Entity {name: $name}) '
                    'WITH e '
                    'MATCH (t:Entity {name: $topic}) '
                    'MERGE (t)-[:RELATED_TO]->(e)',
                    name=ent, topic=query
                )
        print(f'Stored entities for "{query}"')

# Usage
results = search_with_memory('LangGraph agent tutorial')
store_entities_from_results('LangGraph agent tutorial', results)

def get_context_from_memory(topic, depth=2):
    with driver.session() as s:
        # Get related entities up to N hops away
        related = s.run(
            'MATCH (e:Entity {name: $name})-[:RELATED_TO*1..' + str(depth) + ']-(r:Entity) '
            'RETURN DISTINCT r.name AS name, r.type AS type '
            'LIMIT 20',
            name=topic
        ).data()

        # Get recent search results for related topics
        context_results = s.run(
            'MATCH (e:Entity {name: $name})-[:RELATED_TO*1..2]-(r:Entity) '
            'MATCH (sr:SearchResult) WHERE sr.query CONTAINS r.name '
            'RETURN sr.title AS title, sr.snippet AS snippet, sr.url AS url '
            'ORDER BY sr.fetched_at DESC LIMIT 10',
            name=topic
        ).data()

    context = {
        'known_entities': [r['name'] for r in related],
        'related_results': context_results
    }
    print(f'Context: {len(related)} entities, {len(context_results)} cached results')
    return context

ctx = get_context_from_memory('LangGraph agent tutorial')
print(f'Known entities: {ctx["known_entities"][:5]}')