AI For Customer Experiences: A Retail Example

git clone https://github.com/neo4j-product-examples/graphrag-customer-experience.git

#Neo4j Database
NEO4J_URI=neo4j+s://b5d4f951.databases.neo4j.io
NEO4J_USERNAME=retail
NEO4J_PASSWORD=pleaseletmein
NEO4J_DATABASE=neo4j

#OpenAI
OPENAI_API_KEY=sk-...

#Other
# Used by UI to navigate between pages. Only change when hosting remotely
ADVERTISED_ADDRESS="http://localhost"

docker-compose up

docker-compose up --build

docker-compose down

from langchain.vectorstores.neo4j_vector import Neo4jVector
from langchain_openai import OpenAIEmbeddings
import pandas as pd

search_prompt = 'denim jeans'

embedding_model = OpenAIEmbeddings()

# define retriever
vector_only_search = Neo4jVector.from_existing_index(
   embedding=embedding_model,
   url=NEO4J_URI,
   username=NEO4J_USERNAME,
   password=NEO4J_PASSWORD,
   index_name='product_text_embeddings',
   retrieval_query="""
   WITH node AS product, score
   RETURN product.productCode AS productCode,
       product.text AS text, score,
       {score:score, productCode: product.productCode} AS metadata
       ORDER BY score DESC
       """)

# similarity search
res = vector_only_search.similarity_search(search_prompt, k=100)

# visualize as a dataframe
vector_only_df = pd.DataFrame([{'productCode': d.metadata['productCode'],
                               'document': d.page_content,
                               'score': d.metadata['score']} for d in res])
vector_only_df

# define retriever
kg_search = Neo4jVector.from_existing_index(
   embedding=embedding_model,
   url=NEO4J_URI,
   username=NEO4J_USERNAME,
   password=NEO4J_PASSWORD,
   index_name='product_text_embeddings',
   retrieval_query="""
   WITH node AS product, score AS vectorScore

   OPTIONAL MATCH(product)<-[:VARIANT_OF]-(:Article)<-[:PURCHASED]-(:Customer)
   -[:PURCHASED]->(a:Article)<-[:PURCHASED]-(:Customer {customerId: $customerId})

   WITH count(a) AS graphScore,
       product.text AS text,
       vectorScore,
       product.productCode AS productCode
   RETURN text,
       (1+graphScore)*vectorScore AS score,
       {productCode: productCode,
           graphScore:graphScore,
           vectorScore:vectorScore} AS metadata
   ORDER BY graphScore DESC, vectorScore DESC LIMIT 15
   """)


# similarity search (with personalized graph pattern)
CUSTOMER_ID = "daae10780ecd14990ea190a1e9917da33fe96cd8cfa5e80b67b4600171aa77e0"
kg_res = kg_search.similarity_search(search_prompt,
                                    k=100,
                                    params={'customerId': CUSTOMER_ID})

# visualize as a dataframe
vector_kg_df = pd.DataFrame([{'productCode': d.metadata['productCode'],
              'document': d.page_content,
              'vectorScore': d.metadata['vectorScore'],
              'graphScore': d.metadata['graphScore']} for d in kg_res])
vector_kg_df

#merge and compare
(vector_only_df
.reset_index(names='vectorRank')[['productCode', 'vectorRank']]
.merge(vector_kg_df.reset_index(names='graphRank'),
       on='productCode', how='right')
)

content_chain = (
RunnableParallel(
{
'context': (lambda x: (x['customer_interests'], x['customer_id'])) | RunnableLambda(retriever),
'customerName': (lambda x: x['customer_name']),
'customerInterests': (lambda x: x['customer_interests']),
'timeofYear': (lambda x: x['time_of_year']),
})
| prompt
| llm
| StrOutputParser())

from langchain_core.prompts import PromptTemplate

prompt = PromptTemplate.from_template("""
You are a personal assistant named Sally for a fashion, home, and beauty company called HRM.
write an email to {customerName}, one of your customers, to recommend and summarize products based on:
- the current season / time of year: {timeofYear}
- Their recent searches & interests: {customerInterests}

Please only mention the products listed in the context below. Do not come up with or add any new products to the list.
The below candidates are recommended based on the purchase patterns of other customers in the HRM database.
Select the best 4 to 5 product subset from the context that best match
the time of year: {timeofYear} and the customers interests.
Each product comes with an https `url` field.
Make sure to provide that https url with descriptive name text in markdown for each product.

# Context:
{context}
""")

template = (
"You are an assistant that helps customers with their questions. "
"You work for for XYZBrands, a fashion, home, and beauty company. "
"If you require follow up questions, "
"make sure to ask the user for clarification. Make sure to include any "
"available options that need to be clarified in the follow up questions. "
"Embed url links as sources when made available. "
"Answer the question based only on the below Rules and AdditionalContext. "
"The rules should be respected as absolute fact, never provide advice that contradicts the rules. "
"""
# Rules
{rules}

# AdditionalContext
{additionalContext}

# Question:
{question}

# Answer:
"""
)

# support Q&A chain

prompt = ChatPromptTemplate.from_template(template)

qa_chain = (
   RunnableParallel({
       "vectorStoreResults": condense_question |
           vector_store.as_retriever(search_kwargs={'k': vector_top_k}),
       "question": RunnablePassthrough()})
   | RunnableParallel({
       "rules": (lambda x: x["vectorStoreResults"]) |
           RunnableLambda(retrieve_rules),
       "additionalContext": (lambda x: x["vectorStoreResults"]) |
           RunnableLambda(format_docs),
       "question": lambda x: x["question"]})
   | prompt
   | llm
   | StrOutputParser()
)

def retrieve_rules(docs: List[Document]) -> str:
   doc_chunk_ids = [doc.metadata['id'] for doc in docs]
   res = support_graph.query("""
   UNWIND $chunkIds AS chunkId
   MATCH(chunk {id:chunkId})-[:HAS_ENTITY]->()-[rl:!HAS_ENTITY]-{1,5}()
   UNWIND rl AS r
   WITH DISTINCT r
   MATCH (n)-[r]->(m)
   RETURN n.id + ' - ' + type(r) +  ' -> ' + m.id AS rule ORDER BY rule
   """, params={'chunkIds': doc_chunk_ids})
   return '\n'.join([r['rule'] for r in res])