added app files

.gitignore

@@ -0,0 +1,4 @@
+__pycache__
+.env
+venv
+flagged

README.md

@@ -2,7 +2,7 @@
 title: Gpt Claude Dialogue
 emoji: 📚
 colorFrom: purple
-colorTo: yellow
+colorTo: blue
 sdk: gradio
 sdk_version: 3.28.2
 app_file: app.py
@@ -10,4 +10,39 @@ pinned: false
 license: mit
 ---
 
-Check out the configuration reference at https://huggingface.co/docs/hub/spaces-config-reference
+# GPT-3.5 Turbo and Claude-v1.3 Dialogue
+
+This app uses the OpenAI API and the Anthropic API to generate responses between the two AI models. The user can type in a context and see GPT-3.5 Turbo and Claude-v1.3 have a generated conversation with each other.
+
+Enjoy the chaos! Let me know if you have any issues running the app.
+
+To run this app locally:
+
+1. Clone this repository
+
+2. Install the requirements:
+
+```bash
+pip install gradio python-dotenv openai anthropic
+```
+
+3. Obtain API keys for:
+   - OpenAI's API
+   - Anthropic's API
+
+4. Add the API keys to a file called `.env` with the variables:
+
+```
+OPENAI_API_KEY="YOUR_OPENAI_API_KEY"
+CLAUDE_API_KEY="YOUR_CLAUDE_API_KEY" 
+``` 
+
+5. Run the gradio app:
+
+```bash
+gradio run app.py
+```
+
+6. The gradio app will launch in your browser. Type a context to start a conversation between GPT-3.5 Turbo and Claude-v1.3!
+
+7. To close the app, stop the process in your terminal.

app.py

@@ -0,0 +1,90 @@
+import gradio as gr
+from dotenv import load_dotenv
+import os
+import anthropic
+import openai
+from util import ClaudeCompletion, GPTCompletion
+
+gr.close_all()
+
+load_dotenv()
+CLAUDE_API_KEY = os.environ["CLAUDE_API_KEY"]
+openai.api_key = os.environ["OPENAI_API_KEY"]
+
+claudeClient = anthropic.Client(CLAUDE_API_KEY)
+
+def talkToClaude(prompt):
+    completion = ClaudeCompletion(prompt, max_tokens_to_sample=1024)
+    claudeResponse = completion.execute(claudeClient)
+    return claudeResponse
+
+def chatWithClaude(chatHistory):
+    completion = ClaudeCompletion("", max_tokens_to_sample=2048, temperature=0.5)
+    claudeResponse = completion.chatComplete(claudeClient, chatHistory)
+    lastMessage = chatHistory[-1][0]
+    chatHistory.pop()
+    chatHistory.append((lastMessage, claudeResponse))
+    return chatHistory
+
+def startNewChat(system, chatHistory):
+    systemMes = "You are a human chatting with an AI assistant. This is the context of your conversation: " + system
+    completion = GPTCompletion(system=systemMes, max_tokens=2048, temperature=1.5)
+    gptResponse = completion.chatComplete(chatHistory, firstMessage="Hi, I am an AI assistant. How can I help you?")
+    chatHistory.append((gptResponse, ""))
+    return chatHistory
+
+def chatWithGPT(chatHistory):
+    completion = GPTCompletion(system="You are a human chatting with an AI assistant.", max_tokens=2048, temperature=1.5)
+    gptResponse = completion.chatComplete(chatHistory)
+    chatHistory.append((gptResponse, ""))
+    return chatHistory
+
+with gr.Blocks() as demo:
+    chatHistory = []
+    gptsTurn = True
+
+    def startConversation(prompt):
+        global chatHistory, gptsTurn
+        # nextBtn.interactive = False
+        chatHistory = []
+        startNewChat(prompt, chatHistory)
+        # nextBtn.interactive = True
+        gptsTurn = False
+        return chatHistory
+
+    def nextResponse():
+        global gptsTurn
+        # nextBtn.interactive = False
+        if (gptsTurn):
+            chatWithGPT(chatHistory)
+        else:
+            chatWithClaude(chatHistory)
+        gptsTurn = not gptsTurn
+        # nextBtn.interactive = True
+        return chatHistory
+
+    context = gr.Textbox(label="Context",
+                         placeholder="Set the context for two LLMs to chat with each other",
+                         info="OpenAI's gpt-3.5-turbo model with chat completion and Anthropic's claude-v1.3 text completion model will talk to each other. Context will be integrated into GPT's system message for the first line of the dialoge and will be scrapped afterwards. The two LLM's are expected to keep the conversation going based on the conversation history. Clicking \"Start conversation\" will reset the conversation and bring the first message. Then, clicking \"Next response\" will bring the next line of the dialogue.")
+    start_button = gr.Button("Start conversation")
+
+    chatbot = gr.Chatbot().style(height=460)
+    nextBtn = gr.Button("Next response")
+    examples = gr.Examples(
+        ["A person is interested in Formula 1 and asks questions about the sport",
+         "A little child wants to understand how planes fly",
+         "You are a young indie game dev searching for ideas about their next strategy game",
+         "You are an old irish man is interested in medieval european history"]
+        , context)
+    # nextBtn.interactive = False
+    start_button.click(startConversation, context, chatbot, scroll_to_output=True, show_progress=True)
+    nextBtn.click(nextResponse, None, chatbot, scroll_to_output=True, show_progress=True)
+
+try:
+    demo.launch(share=True)
+except KeyboardInterrupt:
+    demo.close()
+except Exception as e:
+    print(e)
+    demo.close()
+    gr.close_all()

util.py

@@ -0,0 +1,113 @@
+import anthropic
+import openai
+
+class ClaudeCompletion:
+    def __init__(
+            self,
+            prompt,
+            model="claude-v1.3",
+            max_tokens_to_sample=256,
+            stop_sequences=[anthropic.HUMAN_PROMPT],
+            stream=False,
+            temperature=1.0,
+            top_k=-1,
+            top_p=-1
+            ):
+        self.model = model
+        self.prompt = prompt
+        self.max_tokens_to_sample = max_tokens_to_sample
+        self.stop_sequences = stop_sequences
+        self.stream = stream
+        self.temperature = temperature
+        self.top_k = top_k
+        self.top_p = top_p
+
+    
+    def execute(self, claudeClient):
+
+        response = claudeClient.completion(
+            prompt = f"{anthropic.HUMAN_PROMPT} {self.prompt} {anthropic.AI_PROMPT}",
+            model = self.model,
+            max_tokens_to_sample = self.max_tokens_to_sample,
+            stop_sequences = self.stop_sequences,
+            steam = self.stream,
+            temperature = self.temperature,
+            top_k = self.top_k,
+            top_p = self.top_p,
+        )
+        return response["completion"].strip()
+    
+    
+    def chatComplete(self, claudeClient, chatHistory):
+
+        for i in range(len(chatHistory)-1):
+            self.prompt = self.prompt + f"{anthropic.HUMAN_PROMPT} {chatHistory[i][0]} {anthropic.AI_PROMPT}"
+            self.prompt = self.prompt + f"{anthropic.AI_PROMPT} {chatHistory[i][1]}"
+        self.prompt = self.prompt + f"{anthropic.HUMAN_PROMPT} {chatHistory[-1][0]} {anthropic.AI_PROMPT}"
+
+        # print("------------anthropic------------")
+        # print(self.prompt)
+
+        response = claudeClient.completion(
+            prompt = self.prompt,
+            model = self.model,
+            max_tokens_to_sample = self.max_tokens_to_sample,
+            stop_sequences = self.stop_sequences,
+            steam = self.stream,
+            temperature = self.temperature,
+            top_k = self.top_k,
+            top_p = self.top_p,
+        )
+        return response["completion"].strip()
+    
+class GPTCompletion:
+    def __init__(
+            self,
+            system="You are a helpful AI assistant",
+            model="gpt-3.5-turbo",
+            temperature=1.0,
+            top_p=1.0,
+            n=1,
+            stream=False,
+            stop=None,
+            max_tokens=256,
+            presence_penalty=0.0,
+            frequency_penalty=0.0,
+            logit_bias={}
+        ):
+        self.system = system
+        self.model = model
+        self.messages = [{"role": "system", "content": f"{self.system}"}]
+        self.temperature = temperature
+        self.top_p = top_p
+        self.n = n
+        self.stream = stream
+        self.stop = stop
+        self.max_tokens = max_tokens
+        self.presence_penalty = presence_penalty
+        self.frequency_penalty = frequency_penalty
+        self.logit_bias = logit_bias
+    
+
+    def chatComplete(self, chatHistory, firstMessage=""):
+
+        self.messages.append({"role": "user", "content": f"{firstMessage}"})
+        for i in range(len(chatHistory)):
+            self.messages.append({"role": "assistant", "content": f"{chatHistory[i][0]}"})
+            self.messages.append({"role": "user", "content": f"{chatHistory[i][1]}"})
+        
+        response = openai.ChatCompletion.create(
+            model=self.model,
+            messages=self.messages,
+            temperature=self.temperature,
+            top_p=self.top_p,
+            n=self.n,
+            stream=self.stream,
+            stop=self.stop,
+            max_tokens=self.max_tokens,
+            presence_penalty=self.presence_penalty,
+            frequency_penalty=self.frequency_penalty,
+            logit_bias=self.logit_bias
+        )
+        
+        return response["choices"][0].message["content"].strip()