Google Cloud Integration

# Authenticate with Application Default Credentials
gcloud auth application-default login

# Set your project
export GOOGLE_CLOUD_PROJECT=your-project-id

# Local Docker for development (matches what CI runs)
docker run -d \
  --name neo4j \
  -p 7474:7474 -p 7687:7687 \
  -e NEO4J_AUTH=neo4j/password \
  -e NEO4J_PLUGINS='["apoc"]' \
  neo4j:5.26-community

from neo4j_agent_memory.embeddings.vertex_ai import VertexAIEmbedder

# Create embedder (gemini-embedding-001 is the default model)
embedder = VertexAIEmbedder(
    project_id="your-gcp-project",  # or set GOOGLE_CLOUD_PROJECT
    location="us-central1",
)

# Generate embeddings
embedding = await embedder.embed("Hello, world!")
print(f"Dimensions: {len(embedding)}")  # 768

# Batch embedding. gemini-embedding-001 accepts one text per request, so the
# embedder issues one call per text; text-embedding-005 and
# text-multilingual-embedding-002 batch up to 250 per request.
embeddings = await embedder.embed_batch([
    "First text",
    "Second text",
    "Third text",
])

# Default: 768 dimensions, compatible with indexes created for the
# retired text-embedding-004 model.
embedder = VertexAIEmbedder()

# Native 3072 dimensions -- best retrieval quality, but the Neo4j vector
# indexes must be created at 3072 (they cannot be resized afterwards).
embedder = VertexAIEmbedder(output_dimensionality=None)

# Middle ground
embedder = VertexAIEmbedder(output_dimensionality=1536)

# For indexing documents
doc_embedder = VertexAIEmbedder(
    model="gemini-embedding-001",
    task_type="RETRIEVAL_DOCUMENT",
)

# For search queries
query_embedder = VertexAIEmbedder(
    model="gemini-embedding-001",
    task_type="RETRIEVAL_QUERY",
)

from neo4j_agent_memory import MemoryClient, MemorySettings
from neo4j_agent_memory.config.settings import Neo4jConfig
from neo4j_agent_memory.llm.adapters.vertex_ai import VertexAIEmbeddingProvider
from pydantic import SecretStr

settings = MemorySettings(
    neo4j=Neo4jConfig(
        uri="bolt://localhost:7687",
        password=SecretStr("password"),
    ),
    embedding=VertexAIEmbeddingProvider(
        "vertex_ai/gemini-embedding-001",
        project_id="your-gcp-project",
        location="us-central1",
        dimensions=768,
    ),
)

async with MemoryClient(settings) as client:
    # All memory operations now use Vertex AI embeddings
    await client.short_term.add_message(
        session_id="user-123",
        role="user",
        content="Hello!",
    )

from neo4j_agent_memory import MemoryClient, MemorySettings
from neo4j_agent_memory.integrations.google_adk import Neo4jMemoryService

async with MemoryClient(settings) as client:
    # Create memory service
    memory_service = Neo4jMemoryService(
        memory_client=client,
        user_id="user-123",
        include_entities=True,
        include_preferences=True,
    )

    # Store a conversation session
    session = {
        "id": "session-1",
        "messages": [
            {"role": "user", "content": "I prefer dark mode"},
            {"role": "assistant", "content": "Noted!"},
        ]
    }
    await memory_service.add_session_to_memory(session)

    # Search across all memory types. search_memory() returns an ADK
    # SearchMemoryResponse — iterate response.memories, not the response.
    response = await memory_service.search_memory(
        query="user preferences",
        limit=10,
    )

    for entry in response.memories:
        # entry.content is a google.genai.types.Content (a list of parts),
        # and the memory type lives in custom_metadata.
        text = "".join(part.text or "" for part in entry.content.parts)
        kind = (entry.custom_metadata or {}).get("memory_type")
        print(f"[{kind}/{entry.author}] {text}")

import os

from google.adk.agents import LlmAgent
from google.adk.runners import Runner
from google.adk.sessions import InMemorySessionService
from google.adk.tools import load_memory
from google.genai import types

from neo4j_agent_memory import MemoryClient, MemorySettings
from neo4j_agent_memory.integrations.google_adk import Neo4jMemoryService

APP, USER, SID = "my-app", "user-123", "session-1"
settings = MemorySettings()

async with MemoryClient(settings) as client:
    session_service = InMemorySessionService()
    memory_service = Neo4jMemoryService(memory_client=client, user_id=USER)

    runner = Runner(
        app_name=APP,
        agent=LlmAgent(
            name="my-agent",
            model=os.environ.get("ADK_MODEL", "gemini-2.5-flash"),
            instruction="Call load_memory to recall anything the user told you before.",
            tools=[load_memory],
        ),
        session_service=session_service,
        memory_service=memory_service,
    )

    await session_service.create_session(app_name=APP, user_id=USER, session_id=SID)

    # run_async() is an async generator — iterate it, never await it.
    async for event in runner.run_async(
        user_id=USER,
        session_id=SID,
        new_message=types.Content(
            role="user", parts=[types.Part(text="I work on Project Alpha")]
        ),
    ):
        pass

    # Commit the finished ADK session to Neo4j so later sessions can recall it.
    await memory_service.add_session_to_memory(
        await session_service.get_session(app_name=APP, user_id=USER, session_id=SID)
    )
    await runner.close()

from neo4j_agent_memory import MemoryClient, MemorySettings

async with MemoryClient(settings) as client:
    # Memory operations use the built-in APIs
    await client.short_term.add_message(
        session_id="user-123",
        role="user",
        content="Show me high-risk customers",
    )

    # Domain queries use the graph client directly
    customers = await client.graph.execute_read(
        """
        MATCH (c:Customer)
        WHERE c.risk_level = 'HIGH'
        RETURN c {.*} AS customer
        ORDER BY c.name
        """,
    )

# stdio transport (for local MCP clients like Claude Desktop)
neo4j-agent-memory mcp serve

# Streamable HTTP transport (for Cloud Run/HTTP deployment).
# Serves the MCP endpoint at POST/GET /mcp/.
neo4j-agent-memory mcp serve --transport http --host 0.0.0.0 --port 8080

# With custom Neo4j connection
neo4j-agent-memory mcp serve \
  --uri bolt://localhost:7687 \
  --password secret

{
  "mcpServers": {
    "neo4j-agent-memory": {
      "command": "neo4j-agent-memory",
      "args": ["mcp", "serve"],
      "env": {
        "NEO4J_URI": "bolt://localhost:7687",
        "NEO4J_PASSWORD": "your-password"
      }
    }
  }
}

from neo4j_agent_memory import MemoryClient, MemorySettings
from neo4j_agent_memory.mcp.server import Neo4jMemoryMCPServer

async with MemoryClient(settings) as client:
    server = Neo4jMemoryMCPServer(client)

    # stdio transport
    await server.run()

    # Or Streamable HTTP
    await server.run_http(host="0.0.0.0", port=8080)

{
  "name": "memory_search",
  "description": "Search across all memory types using hybrid vector + graph search",
  "inputSchema": {
    "type": "object",
    "properties": {
      "query": {
        "type": "string",
        "description": "Search query"
      },
      "limit": {
        "type": "integer",
        "default": 10,
        "description": "Maximum results"
      },
      "memory_types": {
        "type": "array",
        "items": {"type": "string"},
        "description": "Filter by memory types: message, entity, preference"
      }
    },
    "required": ["query"]
  }
}

cd deploy/cloudrun

# Deploy with gcloud
gcloud run deploy neo4j-memory-mcp \
  --source . \
  --region us-central1 \
  --set-secrets NEO4J_URI=neo4j-uri:latest \
  --set-secrets NEO4J_PASSWORD=neo4j-password:latest

FROM python:3.11-slim
WORKDIR /app
COPY . .
RUN pip install neo4j-agent-memory[google,mcp]
EXPOSE 8080
CMD ["neo4j-agent-memory", "mcp", "serve", \
     "--transport", "http", "--host", "0.0.0.0", "--port", "8080"]

# Create secrets
echo -n "neo4j+s://xxx.databases.neo4j.io" | \
  gcloud secrets create neo4j-uri --data-file=-

echo -n "your-password" | \
  gcloud secrets create neo4j-password --data-file=-

# Grant access to Cloud Run service account
gcloud secrets add-iam-policy-binding neo4j-uri \
  --member="serviceAccount:[email protected]" \
  --role="roles/secretmanager.secretAccessor"

cd examples/google_cloud_integration
python full_pipeline.py

cd examples/financial-services-advisor/google-cloud-financial-advisor
cp .env.example .env  # Set GOOGLE_API_KEY, NEO4J_URI, NEO4J_PASSWORD
make install && make load-data && make dev