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
docker run -d \
  --name neo4j \
  -p 7474:7474 -p 7687:7687 \
  -e NEO4J_AUTH=neo4j/password \
  neo4j:5-enterprise

from neo4j_agent_memory.embeddings.vertex_ai import VertexAIEmbedder

# Create embedder
embedder = VertexAIEmbedder(
    model="text-embedding-004",
    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 (up to 250 texts per batch)
embeddings = await embedder.embed_batch([
    "First text",
    "Second text",
    "Third text",
])

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

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

from neo4j_agent_memory import MemoryClient, MemorySettings
from neo4j_agent_memory.config.settings import (
    EmbeddingConfig,
    EmbeddingProvider,
    Neo4jConfig,
)
from pydantic import SecretStr

settings = MemorySettings(
    neo4j=Neo4jConfig(
        uri="bolt://localhost:7687",
        password=SecretStr("password"),
    ),
    embedding=EmbeddingConfig(
        provider=EmbeddingProvider.VERTEX_AI,
        model="text-embedding-004",
        project_id="your-gcp-project",
        location="us-central1",
    ),
)

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
    results = await memory_service.search_memories(
        query="user preferences",
        limit=10,
    )

    for entry in results:
        print(f"[{entry.memory_type}] {entry.content}")

from google.adk import Agent
from neo4j_agent_memory import MemoryClient, MemorySettings
from neo4j_agent_memory.integrations.google_adk import Neo4jMemoryService

# Initialize memory
settings = MemorySettings(...)
memory_client = MemoryClient(settings)
await memory_client.connect()

# Create memory service
memory_service = Neo4jMemoryService(
    memory_client=memory_client,
    user_id="user-123",
)

# Use with ADK Agent
agent = Agent(
    name="my-agent",
    memory=memory_service,
)

# Create custom tools using memory
@agent.tool
async def remember_fact(fact: str) -> str:
    """Store a fact for later recall."""
    await memory_service.add_memory(content=fact, memory_type="message")
    return f"Remembered: {fact}"

@agent.tool
async def recall_memories(query: str) -> list[str]:
    """Search memories for relevant information."""
    results = await memory_service.search_memories(query, limit=5)
    return [entry.content for entry in results]

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-memory mcp serve

# SSE transport (for Cloud Run/HTTP deployment)
neo4j-memory mcp serve --transport sse --port 8080

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

{
  "mcpServers": {
    "neo4j-memory": {
      "command": "neo4j-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 SSE for HTTP
    await server.run_sse(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-memory", "mcp", "serve", "--transport", "sse", "--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:xxx@xxx.iam.gserviceaccount.com" \
  --role="roles/secretmanager.secretAccessor"

cd examples/google_cloud_integration
python full_pipeline.py

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