For further discussion on how Fauna is used as system of record in a generative AI stack and why Logoi is using Fauna as a knowledge graph and metadata store for their gen AI app, please check out Fauna: A modern system of record for your generative AI application.

1. GPT agent collects and processes data: A user interacts with a GPT agent to plan their ideal vacation. The agent asks about their preferences, such as preferred activities, budget, and past travel experiences. As the conversation progresses, the agent collects and processes this information to create a user profile.
2. Storing information in a general-purpose database: The GPT agent stores the user's textual information, such as their name, preferences, and previous travel experiences, in a general-purpose database (in this case, Fauna). This database allows the agent to store structured data and perform complex queries to retrieve relevant information later.
3. Converting information into vectors and storing it in a vector database: The GPT agent converts the user's preferences and past experiences into a high-dimensional vector representation using techniques like word embeddings or sentence embeddings. These vectors are then stored in a vector database, which is optimized for efficient similarity search and vector operations.
4. Embedding recent travel/tourism data for similarity search: In the back end, you can use APIs and a web scraper to collect recent travel and tourism data and, using GPT, turn them into embeddings. Your app can then save these embeddings into a vector database and the relative metadata in Fauna.
5. Generating personalized recommendations: When the user asks for travel recommendations, the GPT agent queries both databases. The GPT agent combines the results from both databases, weighting the importance of each data point to generate a personalized list of travel recommendations. The agent then presents these recommendations to the user in a natural language format, explaining why each destination is a good fit based on the user's preferences and past experiences.

Sample application walk-though

Setting up the project

pip install langchain
pip install fauna

Configure a Fauna database

Seeding the data

from fauna import fql
from fauna.client import Client
from fauna.encoding import QuerySuccess
from fauna.errors import FaunaException
import os

os.environ['FAUNA_SECRET'] = 'fnAFDQEwFtAATYXSvObQ5Es3W1rvscowNqxPnZ_6'

client = Client()
q1 = fql("""
  User.create({ 
    name: "Shadid",
    age: 29
  })
""")

import csv

csv_file_path = "places.csv"

with open(csv_file_path, newline='') as csvfile:
    reader = csv.DictReader(csvfile)
    for row in reader:
      query = fql("Place.create(${x})", x=row)
      res: QuerySuccess = client.query(query)

import openai
import pinecone
from langchain.embeddings.openai import OpenAIEmbeddings
from langchain.text_splitter import CharacterTextSplitter
from langchain.vectorstores import Chroma

os.environ['OPENAI_API_KEY'] = '<Your-Open-AI-Key>'

pinecone.init(api_key="<Your-Pinecone-Key>", environment="northamerica-northeast1-gcp")
openai.api_key = os.environ['OPENAI_API_KEY']
index = pinecone.Index("places")

output = []

with open('places.csv', newline='') as csvfile:
  reader = csv.DictReader(csvfile)
  for i, row in enumerate(reader):
    activities = row['activities']
    generate_embeddings = openai.Embedding.create(input=activities, model="text-embedding-ada-002")
    emb = generate_embeddings['data'][0]['embedding']
    output.append((str(i) + "", emb, { 'state': row['state'], 'name': row['name'] }))

# output
index.upsert(output)

from langchain import PromptTemplate

template = """
Act as a travel agent and find the user's travel preference from following user input
{context}
"""

prompt = PromptTemplate(
    input_variables=["context"],
    template=template,
)

prompt.format(context="<conversation-chain...>")

I like the outdoors. I am looking for a place where there is chances to see wildlife, lots of hiking and I can ride my bike

query = "I like the outdoors. I am looking for a place where there is chances to see wildlife, lots of hiking and I can ride my bike"

xq = openai.Embedding.create(input=query, model="text-embedding-ada-002")['data'][0]['embedding']

res = index.query([xq], top_k=5, include_metadata=True)

res['matches']

from langchain.chains import LLMChain
from langchain.llms import OpenAI

places = res['matches']

places = places[::-1]

places

results = []

for place in places:
  query = fql("Place.where(.name == ${x}) { name, description }", x=place['metadata']['name'])
  item = client.query(query)
  doc = item.data
  results.append(doc.data[0])

results

llm = OpenAI(temperature=0.9)

print(llm(result))