integrate_graphql (#36)

- integrate graphql (d5fdc24444980e5064742cf4de726094d66bcd1d)

app.py

@@ -1,6 +1,6 @@
 from utils import TEMP_DIR, message_dict
 import gradio as gr
-import templates.data_file as data_file, templates.sql_db as sql_db, templates.doc_db as doc_db
+import templates.data_file as data_file, templates.sql_db as sql_db, templates.doc_db as doc_db, templates.graphql as graphql
 
 import os
 from getpass import getpass
@@ -76,6 +76,8 @@ with gr.Blocks(theme=theme, css=css, head=head, delete_cache=(3600,3600)) as dem
         sql_db.demo.render()
     with gr.Tab("Document (MongoDB) Database"):
         doc_db.demo.render()
+    with gr.Tab("GraphQL API"):
+        graphql.demo.render()    
 
     footer = gr.HTML("""<!-- Footer -->
         <footer class="max-w-4xl mx-auto mt-12 text-center text-gray-500 text-sm">

data_sources/__init__.py

@@ -1,5 +1,6 @@
 from .upload_file import process_data_upload
 from .connect_sql_db import connect_sql_db
 from .connect_doc_db import connect_doc_db
+from .connect_graphql import connect_graphql
 
-__all__ = ["process_data_upload","connect_sql_db","connect_doc_db"]
+__all__ = ["process_data_upload","connect_sql_db","connect_doc_db","connect_graphql"]

data_sources/connect_graphql.py

@@ -0,0 +1,145 @@
+import requests
+import os
+import json
+from utils import TEMP_DIR
+
+def connect_graphql(graphql_url, api_token, graphql_token_header, session_hash):
+    try:
+        # Create the GraphQL Introspection Query
+        query = """
+                query IntrospectionQuery {
+                    __schema {
+                    queryType { name }
+                    mutationType { name }
+                    subscriptionType { name }
+                    types {
+                        ...FullType
+                    }
+                    directives {
+                        name
+                        description
+                        locations
+                        args {
+                        ...InputValue
+                        }
+                    }
+                    }
+                }
+                fragment FullType on __Type {
+                    kind
+                    name
+                    description
+                    fields(includeDeprecated: true) {
+                    name
+                    description
+                    args {
+                        ...InputValue
+                    }
+                    type {
+                        ...TypeRef
+                    }
+                    isDeprecated
+                    deprecationReason
+                    }
+                    inputFields {
+                    ...InputValue
+                    }
+                    interfaces {
+                    ...TypeRef
+                    }
+                    enumValues(includeDeprecated: true) {
+                    name
+                    description
+                    isDeprecated
+                    deprecationReason
+                    }
+                    possibleTypes {
+                    ...TypeRef
+                    }
+                }
+                fragment InputValue on __InputValue {
+                    name
+                    description
+                    type { ...TypeRef }
+                    defaultValue
+                }
+                fragment TypeRef on __Type {
+                    kind
+                    name
+                    ofType {
+                    kind
+                    name
+                    ofType {
+                        kind
+                        name
+                        ofType {
+                        kind
+                        name
+                        ofType {
+                            kind
+                            name
+                            ofType {
+                            kind
+                            name
+                            ofType {
+                                kind
+                                name
+                                ofType {
+                                kind
+                                name
+                                }
+                            }
+                            }
+                        }
+                        }
+                    }
+                    }
+                }
+                """
+        print("Connecting to GraphQL Endpoint")
+    
+        # Access a database
+        headers = {"Content-Type": "application/json"}
+        if graphql_token_header and api_token:
+            headers[graphql_token_header] = api_token
+        response = requests.post(graphql_url, headers=headers, json={"query": query})
+        response.raise_for_status()
+
+        introspection_result = response.json()
+
+        client_schema = introspection_result["data"]["__schema"]
+
+        #Generate the list of types
+        type_names_query = """
+                query IntrospectionQuery {
+                    __schema {
+                        types {
+                            name
+                        }
+                    }
+                }
+            """
+        types_response = requests.post(graphql_url, headers=headers, json={"query": type_names_query})
+
+        types_response_results =types_response.json()
+
+        types_names = types_response_results["data"]
+
+        type_names = []
+        for name in types_names["__schema"]["types"]:
+            type_names.append(name["name"])
+
+        session_path = 'graphql'
+
+        dir_path = TEMP_DIR / str(session_hash) / str(session_path)
+        os.makedirs(dir_path, exist_ok=True)
+
+        with open(f'{dir_path}/schema.json', 'w') as fp:
+            json.dump(client_schema, fp, indent=2)
+
+        return ["success","<p style='color:green;text-align:center;font-size:18px;'>GraphQL API connected successful</p>", type_names]
+    except Exception as e:
+        print("GraphQL CONNECTION ERROR")
+        print(e)
+        return ["error",f"<p style='color:red;text-align:center;font-size:18px;font-weight:bold;'>ERROR: {e}</p>"]
+        

functions/__init__.py

@@ -1,9 +1,9 @@
-from .query_functions import SQLiteQuery, sqlite_query_func, PostgreSQLQuery, sql_query_func, doc_db_query_func
+from .query_functions import SQLiteQuery, sqlite_query_func, sql_query_func, doc_db_query_func, graphql_query_func, graphql_schema_query, graphql_csv_query
 from .chart_functions import table_generation_func, scatter_chart_generation_func, \
 line_chart_generation_func, bar_chart_generation_func, pie_chart_generation_func, histogram_generation_func, scatter_chart_fig
-from .chat_functions import sql_example_question_generator, example_question_generator, doc_db_example_question_generator, chatbot_with_fc, sql_chatbot_with_fc, doc_db_chatbot_with_fc
+from .chat_functions import sql_example_question_generator, example_question_generator, doc_db_example_question_generator, chatbot_with_fc, sql_chatbot_with_fc, doc_db_chatbot_with_fc, graphql_chatbot_with_fc, graphql_example_question_generator
 from .stat_functions import regression_func
 
-__all__ = ["SQLiteQuery","sqlite_query_func","sql_query_func","doc_db_query_func","table_generation_func","scatter_chart_generation_func",
+__all__ = ["SQLiteQuery","sqlite_query_func","sql_query_func","doc_db_query_func","graphql_query_func","graphql_schema_query","graphql_csv_query","table_generation_func","scatter_chart_generation_func",
            "line_chart_generation_func","bar_chart_generation_func","regression_func", "pie_chart_generation_func", "histogram_generation_func",
-           "scatter_chart_fig","doc_db_example_question_generator","sql_example_question_generator","example_question_generator","chatbot_with_fc","sql_chatbot_with_fc","doc_db_chatbot_with_fc"]
+           "scatter_chart_fig","doc_db_example_question_generator","sql_example_question_generator","example_question_generator","chatbot_with_fc","sql_chatbot_with_fc","doc_db_chatbot_with_fc","graphql_chatbot_with_fc","graphql_example_question_generator"]

functions/chat_functions.py

@@ -78,6 +78,25 @@ def doc_db_example_question_generator(session_hash, db_collections, db_name, db_
 
     return example_response["replies"][0].text
 
+def graphql_example_question_generator(session_hash, graphql_endpoint, graphql_types):
+    example_response = None
+    example_messages = [
+        ChatMessage.from_system(
+            f"You are a helpful and knowledgeable agent who has access to an GraphQL API endpoint called {graphql_endpoint}."
+        )
+    ]
+
+    example_messages.append(ChatMessage.from_user(text=f"""We have a GraphQL API endpoint with the following types: {graphql_types}.
+                                                  We also have an AI agent with access to the same GraphQL API endpoint that will be performing data analysis.
+                                                  Please return an array of seven strings, each one being a question for our data analysis agent
+                                                  that we can suggest that you believe will be insightful or helpful to a data analysis looking for
+                                                  data insights. Return nothing more than the array of questions because I need that specific data structure
+                                                  to process your response. No other response type or data structure will work."""))
+
+    example_response = chat_generator.run(messages=example_messages)
+
+    return example_response["replies"][0].text
+
 def chatbot_with_fc(message, history, session_hash):
     from functions import sqlite_query_func, table_generation_func, regression_func, scatter_chart_generation_func, \
         line_chart_generation_func,bar_chart_generation_func,pie_chart_generation_func,histogram_generation_func
@@ -218,15 +237,15 @@ def doc_db_chatbot_with_fc(message, history, session_hash, db_connection_string,
     else:
         messages = [
             ChatMessage.from_system(
-                f"""You are a helpful and knowledgeable agent who has access to an NoSQL MongoDB Document database which has a series of collections called {db_collections}.
+                f"""You are a helpful and knowledgeable agent who has access to a NoSQL MongoDB Document database which has a series of collections called {db_collections}.
                 The schema of these collections is: {db_schema}.
-                You also have access to a function, called table_generation_func, that can take a query.csv file generated from our sql query and returns an iframe that we should display in our chat window.
-                You also have access to a scatter plot function, called scatter_chart_generation_func, that can take a query.csv file generated from our sql query and uses plotly dictionaries to generate a scatter plot and returns an iframe that we should display in our chat window.
-                You also have access to a line chart function, called line_chart_generation_func, that can take a query.csv file generated from our sql query and uses plotly dictionaries to generate a line chart and returns an iframe that we should display in our chat window.
-                You also have access to a bar graph function, called line_chart_generation_func, that can take a query.csv file generated from our sql query and uses plotly dictionaries to generate a bar graph and returns an iframe that we should display in our chat window.
-                You also have access to a pie chart function, called pie_chart_generation_func, that can take a query.csv file generated from our sql query and uses plotly dictionaries to generate a pie chart and returns an iframe that we should display in our chat window.
-                You also have access to a histogram function, called histogram_generation_func, that can take a query.csv file generated from our sql query and uses plotly dictionaries to generate a histogram and returns an iframe that we should display in our chat window.
-                You also have access to a linear regression function, called regression_func, that can take a query.csv file generated from our sql query and a list of column names for our independent and dependent variables and return a regression data string and a regression chart which is returned as an iframe.
+                You also have access to a function, called table_generation_func, that can take a query.csv file generated from our MongoDB query and returns an iframe that we should display in our chat window.
+                You also have access to a scatter plot function, called scatter_chart_generation_func, that can take a query.csv file generated from our MongoDB query and uses plotly dictionaries to generate a scatter plot and returns an iframe that we should display in our chat window.
+                You also have access to a line chart function, called line_chart_generation_func, that can take a query.csv file generated from our MongoDB query and uses plotly dictionaries to generate a line chart and returns an iframe that we should display in our chat window.
+                You also have access to a bar graph function, called line_chart_generation_func, that can take a query.csv file generated from our MongoDB query and uses plotly dictionaries to generate a bar graph and returns an iframe that we should display in our chat window.
+                You also have access to a pie chart function, called pie_chart_generation_func, that can take a query.csv file generated from our MongoDB query and uses plotly dictionaries to generate a pie chart and returns an iframe that we should display in our chat window.
+                You also have access to a histogram function, called histogram_generation_func, that can take a query.csv file generated from our MongoDB query and uses plotly dictionaries to generate a histogram and returns an iframe that we should display in our chat window.
+                You also have access to a linear regression function, called regression_func, that can take a query.csv file generated from our MongoDB query and a list of column names for our independent and dependent variables and return a regression data string and a regression chart which is returned as an iframe.
                 Could you please always display the generated charts, tables, and visualizations as part of your output?"""
             )
         ]
@@ -259,4 +278,63 @@ def doc_db_chatbot_with_fc(message, history, session_hash, db_connection_string,
             message_dict[session_hash]['doc_db'].append(response["replies"][0])
             break
         
+    return response["replies"][0].text
+
+def graphql_chatbot_with_fc(message, history, session_hash, graphql_api_string, graphql_api_token, graphql_token_header, graphql_types):
+    from functions import graphql_query_func, graphql_schema_query, graphql_csv_query, table_generation_func, regression_func, scatter_chart_generation_func, \
+        line_chart_generation_func,bar_chart_generation_func,pie_chart_generation_func,histogram_generation_func
+    import tools.tools as tools
+    
+    available_functions = {"graphql_query_func": graphql_query_func,"graphql_schema_query": graphql_schema_query,"graphql_csv_query": graphql_csv_query,"table_generation_func":table_generation_func,
+                           "line_chart_generation_func":line_chart_generation_func,"bar_chart_generation_func":bar_chart_generation_func,
+                           "scatter_chart_generation_func":scatter_chart_generation_func, "pie_chart_generation_func":pie_chart_generation_func,
+                           "histogram_generation_func":histogram_generation_func,
+                           "regression_func":regression_func }
+
+    if message_dict[session_hash]['graphql'] != None:
+        message_dict[session_hash]['graphql'].append(ChatMessage.from_user(message))
+    else:
+        messages = [
+            ChatMessage.from_system(
+                f"""You are a helpful and knowledgeable agent who has access to a GraphQL API which has the following types: {graphql_types}.
+                We have also saved a schema.json file that contains the entire introspection query that we can use to find out more about each type before making a query.
+                You also have access to a function, called table_generation_func, that can take a query.csv file generated from our GraphQL API query and returns an iframe that we should display in our chat window.
+                You also have access to a scatter plot function, called scatter_chart_generation_func, that can take a query.csv file generated from our GraphQL API query and uses plotly dictionaries to generate a scatter plot and returns an iframe that we should display in our chat window.
+                You also have access to a line chart function, called line_chart_generation_func, that can take a query.csv file generated from our GraphQL API query and uses plotly dictionaries to generate a line chart and returns an iframe that we should display in our chat window.
+                You also have access to a bar graph function, called line_chart_generation_func, that can take a query.csv file generated from our GraphQL API query and uses plotly dictionaries to generate a bar graph and returns an iframe that we should display in our chat window.
+                You also have access to a pie chart function, called pie_chart_generation_func, that can take a query.csv file generated from our GraphQL API query and uses plotly dictionaries to generate a pie chart and returns an iframe that we should display in our chat window.
+                You also have access to a histogram function, called histogram_generation_func, that can take a query.csv file generated from our GraphQL API query and uses plotly dictionaries to generate a histogram and returns an iframe that we should display in our chat window.
+                You also have access to a linear regression function, called regression_func, that can take a query.csv file generated from our GraphQL API query and a list of column names for our independent and dependent variables and return a regression data string and a regression chart which is returned as an iframe.
+                Could you please always display the generated charts, tables, and visualizations as part of your output?"""
+            )
+        ]
+        messages.append(ChatMessage.from_user(message))
+        message_dict[session_hash]['graphql'] = messages
+
+    response = chat_generator.run(messages=message_dict[session_hash]['graphql'], generation_kwargs={"tools": tools.graphql_tools_call(graphql_types)})
+
+    while True:
+        # if OpenAI response is a tool call
+        if response and response["replies"][0].meta["finish_reason"] == "tool_calls" or response["replies"][0].tool_calls:
+            function_calls = response["replies"][0].tool_calls
+            for function_call in function_calls:
+                message_dict[session_hash]['graphql'].append(ChatMessage.from_assistant(tool_calls=[function_call]))
+                ## Parse function calling information
+                function_name = function_call.tool_name
+                function_args = function_call.arguments
+
+                ## Find the corresponding function and call it with the given arguments
+                function_to_call = available_functions[function_name]
+                function_response = function_to_call(**function_args, session_hash=session_hash, graphql_api_string=graphql_api_string, 
+                                                    graphql_api_token=graphql_api_token, graphql_token_header=graphql_token_header, session_folder='graphql')
+                print(function_name)
+                ## Append function response to the messages list using `ChatMessage.from_tool`
+                message_dict[session_hash]['graphql'].append(ChatMessage.from_tool(tool_result=function_response['reply'], origin=function_call))
+                response = chat_generator.run(messages=message_dict[session_hash]['graphql'], generation_kwargs={"tools": tools.graphql_tools_call(graphql_types)})
+
+        # Regular Conversation
+        else:
+            message_dict[session_hash]['graphql'].append(response["replies"][0])
+            break
+        
     return response["replies"][0].text

functions/query_functions.py

@@ -2,6 +2,7 @@ from typing import List
 from typing import AnyStr
 from haystack import component
 import pandas as pd
+from pandasql import sqldf
 pd.set_option('display.max_rows', None)
 pd.set_option('display.max_columns', None)
 pd.set_option('display.width', None)
@@ -10,6 +11,8 @@ import sqlite3
 import psycopg2
 from pymongo import MongoClient
 import pymongoarrow.monkey
+import json
+import pluck
 from utils import TEMP_DIR
 import ast
 
@@ -164,4 +167,103 @@ def doc_db_query_func(aggregation_pipeline: List[str], db_collection: AnyStr, se
               You should probably try again.
               """
       print(reply)
-      return {"reply": reply}
+      return {"reply": reply}
+    
+@component
+class GraphQLQuery:
+
+    def __init__(self):
+
+      self.connection = pluck
+
+    @component.output_types(results=List[str], queries=List[str])
+    def run(self, graphql_query, graphql_api_string, graphql_api_token, graphql_token_header, session_hash):
+        print("ATTEMPTING TO RUN GRAPHQL QUERY")
+        dir_path = TEMP_DIR / str(session_hash)
+        results = []
+
+        headers = {"Content-Type": "application/json"}
+        if graphql_token_header and graphql_api_token:
+          headers[graphql_token_header] = graphql_api_token
+
+        print(graphql_query)
+
+        response = self.connection.execute(url=graphql_api_string, headers=headers, query=graphql_query, column_names="short")
+
+        if response.errors:
+           raise ValueError(response.errors)
+        elif response.data:
+          print("DATA FRAME COMPLETE")
+          print(response)
+          response_frame = response.frames['default']
+          print("RESPONSE FRAME")
+          #print(response_frame)
+
+          response_frame.to_csv(f'{dir_path}/graphql/query.csv', index=False)
+          print("CSV COMPLETE")
+          results.append(f"{response_frame}") 
+          return {"results": results, "queries": graphql_query}
+    
+
+
+def graphql_query_func(graphql_query: AnyStr, session_hash, graphql_api_string, graphql_api_token, graphql_token_header, **kwargs):
+    graphql_object = GraphQLQuery()
+    try:
+      result = graphql_object.run(graphql_query, graphql_api_string, graphql_api_token, graphql_token_header, session_hash)
+      print("RESULT")
+      if len(result["results"][0]) > 1000:
+        print("QUERY TOO LARGE")
+        return {"reply": "query result too large to be processed by llm, the query results are in our query.csv file. If you need to display the results directly, perhaps use the table_generation_func function."}
+      else:   
+        return {"reply": result["results"][0]}
+
+    except Exception as e:
+      reply = f"""There was an error running the GraphQL Query = {graphql_query}
+              The error is {e},
+              You should probably try again.
+              """
+      print(reply)
+      return {"reply": reply}
+    
+def graphql_schema_query(graphql_type: AnyStr, session_hash, **kwargs):
+    dir_path = TEMP_DIR / str(session_hash)
+    try:
+      with open(f'{dir_path}/graphql/schema.json', 'r') as file:
+        data = json.load(file)
+
+      types_list = data["types"]
+      result = list(filter(lambda item: item["name"] == graphql_type, types_list))
+
+      print("SCHEMA RESULT")
+      print(graphql_type)
+      print(str(result))
+
+      return {"reply": str(result)}
+
+    except Exception as e:
+      reply = f"""There was an error querying our schema.json file with the type:{graphql_type}
+              The error is {e},
+              You should probably try again.
+              """
+      print(reply)
+      return {"reply": reply}
+
+def graphql_csv_query(csv_query: AnyStr, session_hash, **kwargs):
+    dir_path = TEMP_DIR / str(session_hash)
+    try:
+      query = pd.read_csv(f'{dir_path}/graphql/query.csv')
+      query.Name = 'query'
+      print("GRAPHQL CSV QUERY")
+      queried_df = sqldf(csv_query, locals())
+      print(queried_df)
+      queried_df.to_csv(f'{dir_path}/graphql/query.csv', index=False)
+
+      return {"reply": "The new query results are in our query.csv file. If you need to display the results directly, perhaps use the table_generation_func function."}
+
+    except Exception as e:
+      reply = f"""There was an error querying our query.csv file with the query:{csv_query}
+              The error is {e},
+              You should probably try again.
+              """
+      print(reply)
+      return {"reply": reply}   

requirements.txt

@@ -10,3 +10,5 @@ psycopg2-binary
 pymongo
 pymongoarrow
 pymongo_schema
+pandasql
+pluck

templates/doc_db.py

@@ -17,7 +17,7 @@ with gr.Blocks() as demo:
                          <p style="font-weight:bold;">Notice: the way this system is designed, no login information is retained and credentials are passed as session variables until the user leaves or 
                           refreshes the page in which they disappear. They are never saved to any files. I also make use of the PyMongoArrow aggregate_pandas_all function to apply pipelines,
                           which can't delete, drop, or add database lines to avoid unhappy accidents or glitches.
-                          That being said, it's probably not a good idea to connect a production database to a strange AI tool with an unfamiliar author. 
+                          That being said, it's probably best to use caution when connecting to a production database to a strange AI tool with an unfamiliar author. 
                           This should be for demonstration purposes.</p>
                           <p>Contact me if this is something you would like built in your organization, on your infrastructure, and with the requisite privacy and control a production
                           database analytics tool requires.</p>
@@ -38,7 +38,7 @@ with gr.Blocks() as demo:
     submit.click(fn=hide_info, outputs=description)
 
     @gr.render(inputs=[connection_string,connection_user,connection_password,doc_db_name], triggers=[submit.click])
-    def sql_chat(request: gr.Request, connection_string=connection_string.value, connection_user=connection_user.value, connection_password=connection_password.value, doc_db_name=doc_db_name.value):
+    def db_chat(request: gr.Request, connection_string=connection_string.value, connection_user=connection_user.value, connection_password=connection_password.value, doc_db_name=doc_db_name.value):
         if request.session_hash not in message_dict:
             message_dict[request.session_hash] = {}
         message_dict[request.session_hash]['doc_db'] = None
@@ -78,7 +78,7 @@ with gr.Blocks() as demo:
                 db_name = gr.Textbox(visible=False, value=doc_db_name)
                 db_collections = gr.Textbox(value=process_message[2], interactive=False, label="DB Collections")
                 db_schema = gr.Textbox(visible=False, value=process_message[3])
-                bot = gr.Chatbot(type='messages', label="CSV Chat Window", render_markdown=True, sanitize_html=False, show_label=True, render=False, visible=True, elem_classes="chatbot")
+                bot = gr.Chatbot(type='messages', label="DocDB Chat Window", render_markdown=True, sanitize_html=False, show_label=True, render=False, visible=True, elem_classes="chatbot")
                 chat = gr.ChatInterface(
                                     fn=doc_db_chatbot_with_fc,
                                     type='messages',

templates/graphql.py

@@ -0,0 +1,109 @@
+import ast
+import gradio as gr
+from functions import graphql_example_question_generator, graphql_chatbot_with_fc
+from data_sources import connect_graphql
+from utils import message_dict
+
+import os
+from dotenv import load_dotenv
+
+load_dotenv()
+
+graphql_sample_endpoint = os.getenv("GRAPHQL_SAMPLE_ENDPOINT")
+graphql_sample_api_token = os.getenv("GRAPHQL_SAMPLE_API_TOKEN")
+graphql_sample_header_name = os.getenv("GRAPHQL_SAMPLE_HEADER_NAME")
+
+def hide_info():
+    return gr.update(visible=False)
+
+with gr.Blocks() as demo:
+    description = gr.HTML("""
+                    <!-- Header -->
+                    <div class="max-w-4xl mx-auto mb-12 text-center">
+                        <div class="bg-blue-50 border border-blue-200 rounded-lg max-w-2xl mx-auto">
+                         <p>This tool allows users to communicate with and query real time data from a GraphQL API endpoint using natural
+                          language and the above features.</p>
+                         <p style="font-weight:bold;">Notice: the way this system is designed, no login information is retained and credentials are passed as session variables until the user leaves or 
+                          refreshes the page in which they disappear. They are never saved to any files.</p>
+                          <p style="font-weight:bold;"> I don't include a function that allows the system to run mutations and I instruct the agent to not alter any data, but it could in theory be possible,
+                          although my testing wasn't able to get the system to alter or write to the api. I would be careful to make sure permissions are restricted for the
+                          api token being used.
+                          And of course, it's probably best to use caution when connecting to a strange AI tool with an unfamiliar author. 
+                          This should be for demonstration purposes.</p>
+                          <p>Contact me if this is something you would like built in your organization, on your infrastructure, and with the requisite privacy and control a production
+                          database analytics tool requires.</p>
+                        </div>
+                    </div>
+                        """, elem_classes="description_component")
+    
+    status_message = gr.HTML(value='<p style="color:green;text-align:center;font-size:18px;">Please be patient while connecting as we need to generate '
+    'and read a schema before connection can be successful. This process can take a few minutes.</p>', padding=False)
+
+    graphql_url = gr.Textbox(label="GraphQL Endpoint URL", value=graphql_sample_endpoint)
+    with gr.Row():
+        api_token_header_name = gr.Textbox(label="API Token Header Name", value=graphql_sample_header_name)
+        api_token = gr.Textbox(label="API Token", value=graphql_sample_api_token, type="password")
+
+    submit = gr.Button(value="Submit")
+    submit.click(fn=hide_info, outputs=description)
+
+    @gr.render(inputs=[graphql_url,api_token,api_token_header_name], triggers=[submit.click])
+    def api_chat(request: gr.Request, graphql_url=graphql_url.value, api_token=api_token.value, api_token_header_name=api_token_header_name.value):
+        if request.session_hash not in message_dict:
+            message_dict[request.session_hash] = {}
+        message_dict[request.session_hash]['graphql'] = None
+        if graphql_url:
+            print("GraphQL API")
+            process_message = process_graphql(graphql_url, api_token, api_token_header_name, request.session_hash)
+            gr.HTML(value=process_message[1], padding=False)
+            if process_message[0] == "success":
+                if "qdl-app-testing" in graphql_url:
+                    example_questions = [
+                                            ["Describe the dataset"],
+                                            ["What is the total revenue for this shopify store?"],
+                                            ["What is the average duration from the fulfillment of an order to its delivery?"],
+                                            ["What is the total value of orders processed in the current month?"],
+                                            ["Which product has the highest number of variants in the inventory?"],
+                                            ["How many gift cards have been issued this year, and what is their total value?"],
+                                            ["How many active apps are currently installed on the store?"],
+                                            ["What is the total count of abandoned checkouts over the last month?"]
+                                        ]
+                else:
+                    try:
+                        generated_examples = ast.literal_eval(graphql_example_question_generator(request.session_hash, graphql_url, process_message[2]))
+                        example_questions = [
+                                                ["Describe the dataset"]
+                                            ]
+                        for example in generated_examples:
+                            example_questions.append([example])
+                    except Exception as e:
+                        print("GRAPHQL QUESTION GENERATION ERROR")
+                        print(e)
+                        example_questions = [
+                                            ["Describe the dataset"],
+                                            ["List the columns in the dataset"],
+                                            ["What could this data be used for?"],
+                                        ]
+                session_hash = gr.Textbox(visible=False, value=request.session_hash)
+                graphql_api_string = gr.Textbox(visible=False, value=graphql_url)
+                graphql_api_token = gr.Textbox(visible=False, value=api_token)
+                graphql_token_header = gr.Textbox(visible=False, value=api_token_header_name)
+                graphql_types = gr.Textbox(value=process_message[2], interactive=False, label="GraphQL Types")
+                bot = gr.Chatbot(type='messages', label="GraphQL Chat Window", render_markdown=True, sanitize_html=False, show_label=True, render=False, visible=True, elem_classes="chatbot")
+                chat = gr.ChatInterface(
+                                    fn=graphql_chatbot_with_fc,
+                                    type='messages',
+                                    chatbot=bot,
+                                    title="Chat with your Graphql API",
+                                    examples=example_questions,
+                                    concurrency_limit=None,
+                                    additional_inputs=[session_hash, graphql_api_string, graphql_api_token, graphql_token_header, graphql_types]
+                                    )
+            
+    def process_graphql(graphql_url, api_token, api_token_header_name, session_hash):
+        if graphql_url:
+            process_message = connect_graphql(graphql_url, api_token, api_token_header_name, session_hash)
+        return process_message            
+
+if __name__ == "__main__":
+    demo.launch()

templates/sql_db.py

@@ -17,7 +17,7 @@ with gr.Blocks() as demo:
                          <p style="font-weight:bold;">Notice: the way this system is designed, no login information is retained and credentials are passed as session variables until the user leaves or 
                           refreshes the page in which they disappear. They are never saved to any files. I also make use of the Pandas read_sql_query function to apply SQL 
                           queries, which can't delete, drop, or add database lines to avoid unhappy accidents or glitches.
-                          That being said, it's probably not a good idea to connect a production database to a strange AI tool with an unfamiliar author. 
+                          That being said, it's probably best to use caution when connecting to a production database to a strange AI tool with an unfamiliar author. 
                           This should be for demonstration purposes.</p>
                           <p>Contact me if this is something you would like built in your organization, on your infrastructure, and with the requisite privacy and control a production
                           database analytics tool requires.</p>
@@ -76,7 +76,7 @@ with gr.Blocks() as demo:
                 db_pass = gr.Textbox(visible=False, value=sql_pass)
                 db_name = gr.Textbox(visible=False, value=sql_db_name)
                 db_tables = gr.Textbox(value=process_message[2], interactive=False, label="SQL Tables")
-                bot = gr.Chatbot(type='messages', label="CSV Chat Window", render_markdown=True, sanitize_html=False, show_label=True, render=False, visible=True, elem_classes="chatbot")
+                bot = gr.Chatbot(type='messages', label="SQL DB Chat Window", render_markdown=True, sanitize_html=False, show_label=True, render=False, visible=True, elem_classes="chatbot")
                 chat = gr.ChatInterface(
                                     fn=sql_chatbot_with_fc,
                                     type='messages',

tools/tools.py

@@ -98,14 +98,84 @@ def doc_db_tools_call(db_collections):
                     "properties": {
                         "aggregation_pipeline": {
                             "type": "string",
-                            "description": "The MongoDB aggregation pipeline to use in the search. Infer this from the user's message. It should be a question or a statement"
+                            "description": "The MongoDB aggregation pipeline to use in the search. Infer this from the user's message. It should be a question or a statement."
                         },
                         "db_collection": {
                             "type": "string",
-                            "description": "The MongoDB collection to use in the search. Infer this from the user's message. It should be a question or a statement",
+                            "description": "The MongoDB collection to use in the search. Infer this from the user's message. It should be a question or a statement.",
                         }
                     },
-                    "required": ["queries","db_collection"],
+                    "required": ["aggregation_pipeline","db_collection"],
+                },
+            },
+        },
+    ]
+
+    tools_calls.extend(chart_tools)
+    tools_calls.extend(stats_tools)
+
+    return tools_calls
+
+def graphql_tools_call(graphql_types):
+    
+    types_string = (graphql_types[:625] + '..') if len(graphql_types) > 625 else graphql_types
+        
+    tools_calls = [
+        {
+            "type": "function",
+            "function": {
+                "name": "graphql_query_func",
+                "description": f"""This is a tool useful to build a GraphQL query for a GraphQL API endpoint with the following types, {types_string}.
+                There may also be more types in the GraphQL endpoint if the number of types is too large to process. 
+                This function also saves the results of the query to a csv file called query.csv.""",
+                "parameters": {
+                    "type": "object",
+                    "properties": {
+                        "graphql_query": {
+                            "type": "string",
+                            "description": "The GraphQL query to use in the search. Infer this from the user's message. It should be a question or a statement."
+                        }
+                    },
+                    "required": ["graphql_query"],
+                },
+            },
+        },
+        {
+            "type": "function",
+            "function": {
+                "name": "graphql_schema_query",
+                "description": f"""This is a tool useful to query a GraphQL type and receive back information about its schema. This is useful because
+                the GraphQL introspection query is too large to be ingested all at once and this allows us to query the schema one type at a time to 
+                view it in manageable bites. You may realize after viewing the schema, that the type you selected was not appropriate for the question
+                you are attempting answer. You may then query additional types to find the appropriate types to use for your GraphQL API query.""",
+                "parameters": {
+                    "type": "object",
+                    "properties": {
+                        "graphql_type": {
+                            "type": "string",
+                            "description": "The GraphQL type that we want to view the schema of in order to make the proper query with our graphql_query_func. Infer this from the user's message. It should be a question or a statement."
+                        }
+                    },
+                    "required": ["graphql_type"],
+                },
+            },
+        },
+        {
+            "type": "function",
+            "function": {
+                "name": "graphql_csv_query",
+                "description": f"""This is a tool useful to SQL query our query.csv file that is generated from our GraphQL query. This is useful in a situation
+                where the results of the GraphQL query need additional querying to answer the user question.  The query.csv file is converted to a Pandas dataframe
+                and we query that dataframe with SQL on a table called 'query' before converting it back to a csv file.""",
+                "parameters": {
+                    "type": "object",
+                    "properties": {
+                        "csv_query": {
+                            "type": "string",
+                            "description": "The pandas dataframe SQL query to use in the search. The table that we query is named 'query'. Infer this from the user's message. It should be a question or a statement"
+                        }
+                    },
+                    "required": ["csv_query"],
                 },
             },
         },