The Conversation Model

Retrieval Tool

When the human asks for a recommendation based on its plot, the chatbot will embed the rephrased question and search the vector index for similar embeddings. The text associated with those embeddings will be appended to the prompt, allowing the LLM to use the information to generate a natural language answer.

At the same time, the chain will be responsible for creating a :CONTEXT relationship from the (:Response) node to the node that contains the embedding.

Cypher Tool

As the human asks more complex questions, the chatbot must fall back to the Cypher tool, which will generate and execute a Cypher statement capable of answering the rephrased question.

The Cypher generation prompt must include instructions to return the elementId of the node along with any relevant properties. This will provide the chain with the information needed to create the :CONTEXT relationship, which, in turn, will provide additional clarity on the response.

The (:Response) node should also store the generated Cypher statement.

Note also the addition of the .cypher property on the (: Response), which will clarify the Cypher statement used to query the database.

Saving the conversation history

The chatbot must create a (:Response) node that contains the original input, the rephrased question, and the output from the LLM.

As users receive one or more responses within a session, this forms a natural hierarchy of (:Session) nodes, each containing relationships to many (:Response) nodes.

Regardless of which chain creates it, the (:Response) node should hold the following properties:

Creating a Response Chain

Creating a chain of :NEXT relationships between responses will provide an optimal way to find the conversation history.

When adding a new response, the chatbot must create an additional :LAST_RESPONSE relationship from the (:Session) node. This relationship offers a shortcut to locate the latest response in the session, from which one can follow the :NEXT relationship to trace the recent response history.

Using the :LAST_RESPONSE relationship to obtian recent message history will be more performant than collecting all responses in memory and ordering by the .createdAt timestamp. From there, you will follow the path of :NEXT relationships in a variable-length traversal to obtain a list of previous messages.

This :LAST_RESPONSE pointer will need to be actively maintained, removing any old relationships before creating a new one to ensure the pointer always points to the latest response.

Modeling Decisions

You can learn more about modeling nodes and relationships in the Graph Data Modelling Fundamentals course.

Saving responses

You will use the following Cypher statement to save conversation history to the database.

MERGE (session:Session { id: $sessionId }) // (1)

// <2> Create new response
CREATE (response:Response {
  id: randomUuid(),
  createdAt: datetime(),
  source: $source,
  input: $input,
  output: $output,
  rephrasedQuestion: $rephrasedQuestion,
  cypher: $cypher
})
CREATE (session)-[:HAS_RESPONSE]->(response)

WITH session, response

CALL {
  WITH session, response

  // <3> Remove existing :LAST_RESPONSE relationship if it exists
  MATCH (session)-[lrel:LAST_RESPONSE]->(last)
  DELETE lrel

  // <4? Create :NEXT relationship
  CREATE (last)-[:NEXT]->(response)
}

// <5> Create new :LAST_RESPONSE relationship
CREATE (session)-[:LAST_RESPONSE]->(response)

// <6> Create relationship to context nodes
WITH response

CALL {
  WITH response
  UNWIND $ids AS id
  MATCH (context)
  WHERE elementId(context) = id
  CREATE (response)-[:CONTEXT]->(context)

  RETURN count(*) AS count
}

RETURN DISTINCT response.id AS id

The statement performs the following actions:

Rephasing Questions

In the next lesson, you will build a chain that utilizes the conversation history to rephrase a question into a standalone question.

Check Your Understanding