Chat History

Comparing OpenAI Chatbot & Gemini Chatbot

Gemini has added the Files API, which can allow multi-modal input, such as documents and images. The process of building an app with the Gemini API is very similar to OpenAI. There are many overlapping features between the two. When building the app for this lesson, you’ll utilize system conversation history in a similar way as you did with OpenAI. You’ll also use system instructions to customize the model. OpenAI has a similar parallel function calling feature. Lastly, you can format your responses from Gemini in JSON and provide a schema to make it more advanced.

Deciding Between Gemini and ChatGPT Based on Results

If you’re already working heavily within the Google Cloud ecosystem and need an information retrieval-focused chatbot, Gemini is a good choice. If you prioritize creative generation, conversational abilities, customization, and broad platform integration, ChatGPT could be a better fit. Both APIs are rapidly evolving, so it’s crucial to stay updated with the latest developments. Consider factors like project requirements, model capabilities, cost, and the development ecosystem when making your decision.

Chat History

Chat history is an important aspect of a request because it maintains conversation context. First, you’ll compare the OpenAI module app with the one you’re building in this module.

Defining Conversation Context

Conversation history, in the context of AI text generation, refers to the record of previous interactions within a dialogue. This record serves as the conversational context, providing the AI model with crucial information about the ongoing discussion. The context derived from previous interactions includes current topics, user preferences, and established relationships.

Utilizing conversation history is paramount in generating meaningful and relevant responses. Without this context, AI models risk producing disjointed or repetitive outputs. Previous responses aren’t taken into consideration. In essence, conversation history acts as the AI’s memory during a conversation. The AI can build upon prior exchanges and deliver responses that are meaningful to the current context. Conversation history is provided to each API call via the history object of the request. By default, without maintaining the history,  the chat will maintain no context.

Using the Chat History Object

The history is included as part of the response. It can be a single item or a list of items. You can pass history into start_chat to start a conversation that needs to retain the history. You won’t need any extra parameters when using start_chat. You can also provide a conversation history when you call start_chat:

chat_session = model.start_chat(
  history = [
    {
      "role": "user",
      "parts": [
        "I have two dogs and three cats.",
      ],
    },
    {
      "role": "model",
      "parts": [
        "That's a full house! 🐶🐶🐱🐱🐱\n\nDo you have any fun stories about them or
        are you looking for tips on how to manage a multi-pet household? Tell me more
        about your furry family! 😊 \n",
      ],
    },
    {
      "role": "user",
      "parts": [
        "That sounds like a wonderful menagerie!",
      ],
    },
    {
      "role": "model",
      "parts": [
        "You're right, \"menagerie\" is a perfect word for it!
        It sounds like you appreciate a lively, animal-loving home. 😊 \n\n
        Do you have any pets yourself? \n",
      ],
    },
  ]
)

The above code passes a JSON chat history to start_chat so the conversation will have some context. Each response has a role in determining who said it. The text for the response is inside parts.  

Understanding Roles

In Gemini, there are only two roles to consider: the model and the user. Unlike the OpenAI app, Gemini doesn’t support System. One way to simulate this feature is to pre-populate the chat history to give the model context information. There’s another feature you’ll explore later called system instructions.

Now that the multiturn chat has started, any subsequent queries will include the preset conversation history:

response = chat_session.send_message("How many paws are in my house?")

The above code calls send_message to ask a question based on the context provided in the history earlier. When the above code executes, the result looks like this:

That's a fun math problem! Let's solve it:

* **Dogs:** 2 dogs * 4 paws/dog = 8 paws
* **Cats:** 3 cats * 4 paws/cat = 12 paws

**Total: 8 paws + 12 paws = 20 paws**

You have a grand total of 20 paws running around your house!  🐾

The model considers the conversation history in its response and correctly deduces that there are twenty paws in the household. Each new message sent on chat_session will be added to the history.

send_message can also accept safety settings and configuration parameters along with conversation history as arguments when needed. The configuration and safety settings will override the model’s settings for this request. Now that you understand how conversation history works with the Gemini API, it’s time to write some code.