Upload 14 files

Seed_Dataset.csv

@@ -0,0 +1,263 @@
+QUERY,REASONING
+Query:Summarize issues similar to don:core:dvrv-us-1:devo/0:issue/1,"We need to summarize issues similar to don:core:dvrv-us-1:devo/0:issue/1 which we can see is an ID (a unique identifier for an issue) so we will first call the ""get_similar_work_items"" API with argument name : ""work_id"" and argument_value: ""don:core:dvrv-us-1:devo/0:issue/1"" since we need to get similar issues. 
+
+Next,   we will call the ""summarize_objects"" API with argument_name: ""objects"" and argument_value: ""$$PREV[0]"" since we need to then summarize the issues and we can refer the value of the ith chain using ""$$PREV[0]"". Therefore, the answer is: [(tool_name: get_similar_work_items, argument_name: work_id, argument_value: don:core:dvrv-us-1:devo/0:issue/1), (tool_name: summarize_objects), (argument_name: objects, argument_value: $$PREV[0]),]"
+Query: Prioritize my P0 issues and add them to the current sprint,"To prioritize your P0 issues and add them to the current sprint, we need to perform the following steps using the provided APIs:
+
+1. **Identify the User:** First, we need to identify who ""my"" refers to in the query. We will use the `who_am_i` API to get the ID of the current user.
+   - Tool Name: `who_am_i`
+   - Arguments: []
+
+2. **List P0 Issues Owned by the User:** Next, we need to list all the P0 issues that are owned by the user. We will use the `works_list` API with three arguments:
+   - Tool Name: `works_list`
+   - Arguments: 
+     - (argument_name: `owned_by`, argument_value: `$$PREV[0]`)
+     - (argument_name: `issue.priority`, argument_value: `['p0']`)
+     - (argument_name: `type`, argument_value: `['issue']`)
+
+3. **Prioritize the Retrieved Issues:** Once we have the list of P0 issues, we need to prioritize them. We will use the `prioritize_objects` API with the list of issues obtained from the previous step.
+   - Tool Name: `prioritize_objects`
+   - Arguments: 
+     - (argument_name: `objects`, argument_value: `$$PREV[1]`)
+
+4. **Get Current Sprint ID:** To add these issues to the current sprint, we first need to know the ID of the current sprint. We will use the `get_sprint_id` API.
+   - Tool Name: `get_sprint_id`
+   - Arguments: []
+
+5. **Add Prioritized Issues to the Current Sprint:** Finally, we will use the `add_work_items_to_sprint` API to add the prioritized P0 issues to the current sprint. We will use two arguments: the list of prioritized work IDs and the sprint ID.
+   - Tool Name: `add_work_items_to_sprint`
+   - Arguments: 
+     - (argument_name: `work_ids`, argument_value: `$$PREV[2]`)
+     - (argument_name: `sprint_id`, argument_value: `$$PREV[3]`)
+
+Therefore, the answer is:
+- [(tool_name: `who_am_i`, arguments: []),
+- (tool_name: `works_list`, arguments: [(argument_name: `owned_by`, argument_value: `$$PREV[0]`), (argument_name: `issue.priority`, argument_value: `['p0']`), (argument_name: `type`, argument_value: `['issue']`)]),
+- (tool_name: `prioritize_objects`, arguments: [(argument_name: `objects`, argument_value: `$$PREV[1]`)]),
+- (tool_name: `get_sprint_id`, arguments: []),
+- (tool_name: `add_work_items_to_sprint`, arguments: [(argument_name: `work_ids`, argument_value: `$$PREV[2]`), (argument_name: `sprint_id`, argument_value: `$$PREV[3]`)])]"
+"Query: Summarize high severity tickets from the customer UltimateCustomer
+","To summarize high severity tickets from the customer named ""UltimateCustomer,"" we need to follow these steps:
+
+1. First, we need to identify the ID of the object (in this case, the customer ""UltimateCustomer"") using the `search_object_by_name` API. This is because we need the ID to filter tickets related to this customer. So, we will call `search_object_by_name` with the argument `(argument_name: query, argument_value: UltimateCustomer)`.
+
+2. Next, we will use the `works_list` API to retrieve the list of high severity tickets related to ""UltimateCustomer."" For this, we need three arguments: 
+   - `(argument_name: ticket.severity, argument_value: high)` to filter for high severity tickets,
+   - `(argument_name: ticket.source_channel, argument_value: $$PREV[0])` to filter tickets related to ""UltimateCustomer"" (using the ID retrieved from the previous step),
+   - `(argument_name: type, argument_value: ticket)` to ensure we are only retrieving tickets.
+
+3. Finally, we need to summarize the retrieved tickets. We do this by calling the `summarize_objects` API with the argument `(argument_name: objects, argument_value: $$PREV[1])`, where `$$PREV[1]` refers to the list of high severity tickets related to ""UltimateCustomer.""
+
+Therefore, the answer is: 
+- [(tool_name: search_object_by_name, arguments= [(argument_name: query, argument_value: UltimateCustomer)]), 
+- (tool_name: works_list, arguments= [(argument_name: ticket.severity, argument_value: high), (argument_name: ticket.source_channel, argument_value: $$PREV[0]), (argument_name: type, argument_value: ticket)]), 
+- (tool_name: summarize_objects, arguments= [(argument_name: objects, argument_value: $$PREV[1])])]
+"
+"Query: What are my all issues in the triage stage under part FEAT-123? Summarize them. 
+
+","Since the query has specified that we have find the issues of the person sending the query, we need to call the ""whoami"" API first to identify the person. After that we need to call the ""works_list"" API to get all the issues with three arguments here since we: 1) have to get the tools in triage stage, 2) identify tools under part ""FEAT-123"", 3) Identify the matching tools that are owned by the person asking the query. Therefore, the three arguments are (with the format: (argument_name, argument_value)): 1) (stage.name, triage) 2) (applies_to_part, FEAT-123) 3) (owned_by, $$PREV[0]).  Finally, we will call the ""summarize_objects"" tool with argument_name: ""objects"" and argument_value: '""$$PREV[1]"" since we are tasked to summarize all these issues. Thus the answer is : [(tool_name: whoami, arguments =[ ], (tool_name: works_list, arguments= ([argument_name: stage.name, argument_value: triage], [argument_name:applies_to_part, argument_value: FEAT-123], [argument_name: owned_by, argument_value: $$PREV[0]]),(tool_name: summarize_objects, (arguments = ([argument_name: objects, argument_value: $$PREV[0]),])]"
+"Query:List all high severity tickets coming in from slack from customer Cust123 and generate a summary of them. 
+","To solve this task, we need to perform the following steps:
+
+1. **Find the ID of the customer ""Cust123""**: Since we need to filter tickets by a specific customer, we first need to identify the ID of ""Cust123"". We can do this by calling the `search_object_by_name` API with the argument `(query, Cust123)`.
+
+2. **List all high severity tickets from Slack related to ""Cust123""**: After obtaining the customer ID, we need to list the tickets. For this, we call the `works_list` API with three arguments: `(ticket.severity, high)`, `(ticket.source_channel, slack)`, and `(reported_by, $$PREV[0])`. Here, `$$PREV[0]` refers to the output of the first API call, which is the ID of ""Cust123"".
+
+3. **Generate a summary of these tickets**: Finally, we will call the `summarize_objects` API to summarize the tickets. The argument for this call is `(objects, $$PREV[1])`, where `$$PREV[1]` refers to the list of tickets obtained from the `works_list` API.
+
+Therefore, the answer is:
+
+1. \[(tool_name: search_object_by_name, arguments: \[(argument_name: query, argument_value: Cust123)\])\],
+2. \[(tool_name: works_list, arguments: \[(argument_name: ticket.severity, argument_value: high), (argument_name: ticket.source_channel, argument_value: slack), (argument_name: reported_by, argument_value: $$PREV[0])\])\],
+3. \[(tool_name: summarize_objects, arguments: \[(argument_name: objects, argument_value: $$PREV[1])\])\]."
+"Query: Given a customer meeting transcript T, create action items and add them to my current sprint ","To solve the given task, we need to follow these steps:
+
+1. **Extract Actionable Tasks from Meeting Transcript**: First, we need to extract actionable tasks from the given customer meeting transcript. We will use the `create_actionable_tasks_from_text` API with the argument `text` set to the transcript \(T\).
+
+
+2. **Get Current Sprint ID**: To add the tasks to the current sprint, we need to identify the current sprint. We will use the `get_sprint_id` API for this.
+
+3. **Add Extracted Tasks to Sprint**: Finally, we will add the extracted tasks to the identified sprint. We will use the `add_work_items_to_sprint` API with two arguments: `work_ids` set to the result of the `create_actionable_tasks_from_text` API (using $$PREV[0]), and `sprint_id` set to the result of the `get_sprint_id` API (using $$PREV[2]).
+
+Therefore, the answer is:
+1. \[(tool_name: create_actionable_tasks_from_text, argument_name: text, argument_value: T)\],
+2. \[(tool_name: get_sprint_id, arguments: [ ])\],
+3. \[(tool_name: add_work_items_to_sprint, arguments: [\[argument_name: work_ids, argument_value: $$PREV[0]\], \[argument_name: sprint_id, argument_value: $$PREV[2]\]])\]."
+Query: What are all the low severity tickets created by InferiorCustomer which needs a response? Generate a summary of them.,"To solve this task, we will need to use multiple APIs in sequence. 
+
+First, we will call the `search_object_by_name` API to find the ID of ""InferiorCustomer"". We will use the argument `query` with the value ""InferiorCustomer"".
+
+Next, we need to retrieve all the low severity tickets created by ""InferiorCustomer"" which need a response. For this, we will use the `works_list` API with three arguments:
+1. `created_by` with the value of $$PREV[0] to refer to the ID of ""InferiorCustomer"".
+2. `ticket.severity` with the value ""low"".
+3. `ticket.needs_response` with the value `true`.
+
+Finally, we will summarize these tickets. We use the `summarize_objects` API with the argument `objects` set to the value of $$PREV[1], which refers to the list of tickets retrieved in the previous step.
+
+Therefore, the answer is:
+1. (tool_name: search_object_by_name, arguments = [argument_name: query, argument_value: InferiorCustomer]),
+2. (tool_name: works_list, arguments = [argument_name: created_by, argument_value: $$PREV[0]], [argument_name: ticket.severity, argument_value: low], [argument_name: ticket.needs_response, argument_value: true]),
+3. (tool_name: summarize_objects, arguments = [argument_name: objects, argument_value: $$PREV[1]])."
+"Query: Find work items that need a response and are associated with Rev organizations ""Walter LTD"" and ""Hank Products."" List them and summarize their details.","To address the query ""Find work items that need a response and are associated with Rev organizations 'Walter LTD' and 'Hank Products.' List them and summarize their details,"" we need to execute a sequence of API calls with specific arguments. Here is the ordered list of APIs and their corresponding arguments needed to solve this task:
+
+1. **API Call:** `works_list`
+   - **Arguments:**
+     - `ticket.needs_response`: `true`
+     - `ticket.rev_org`: `[""Walter LTD"", ""Hank Products""]`
+   - This API call will retrieve a list of work items that require a response and are associated with the specified Rev organizations, ""Walter LTD"" and ""Hank Products.""
+
+2. **API Call:** `summarize_objects`
+   - **Arguments:**
+     - `objects`: `$$PREV[0]`
+   - This API call uses the output from the first API call to summarize the details of the retrieved work items.
+
+Therefore, the answer is: 
+1. [(tool_name: works_list, arguments= ([argument_name: ticket.needs_response, argument_value: true], [argument_name: ticket.rev_org, argument_value: [""Walter LTD"", ""Hank Products""]))]
+2. [(tool_name: summarize_objects, arguments= ([argument_name: objects, argument_value: $$PREV[0]),])]
+
+This sequence of API calls will effectively find and summarize the required work items."
+"Query: Get the ID of the current sprint and add the work items with IDs ""WK-123"" and ""WK-456"" to it.
+","To solve the task of getting the ID of the current sprint and adding the work items with IDs ""WK-123"" and ""WK-456"" to it, we need to sequentially call two APIs.
+
+First, we call the `get_sprint_id` API to retrieve the ID of the current sprint. This API does not require any arguments.
+
+Next, we use the `add_work_items_to_sprint` API to add the specified work items to the sprint. This requires two arguments:
+1. `work_ids`: The IDs of the work items to be added to the sprint. In this case, the values are [""WK-123"", ""WK-456""].
+2. `sprint_id`: The ID of the sprint to which the items should be added. Here, we use the sprint ID obtained from the first API call, referenced as `$$PREV[0]`.
+
+Therefore, the solution is:
+1. [(tool_name: get_sprint_id, arguments: [])]
+2. [(tool_name: add_work_items_to_sprint, arguments: [(argument_name: work_ids, argument_value: [""WK-123"", ""WK-456""]), (argument_name: sprint_id, argument_value: $$PREV[0])])]"
+"Query: List the first 10 work items owned by user Jonathan in the ""Development"" stage and summarize them.","To solve the task of listing the first 10 work items owned by user Jonathan in the ""Development"" stage and summarizing them, we need to use the following APIs and their arguments:
+
+1. **API Call:** `works_list`
+   - **Arguments:**
+     - `(argument_name: owned_by, argument_value: [""Jonathan""])` – To filter work items owned by Jonathan.
+     - `(argument_name: stage.name, argument_value: [""Development""])` – To filter work items in the Development stage.
+     - `(argument_name: limit, argument_value: 10)` – To limit the result to the first 10 work items.
+
+2. **API Call:** `summarize_objects`
+   - **Arguments:**
+     - `(argument_name: objects, argument_value: $$PREV[0])` – To summarize the list of work items retrieved from the previous API call.
+
+Therefore, the answer is: 
+- [(tool_name: works_list, arguments= ([argument_name: owned_by, argument_value: [""Jonathan""]], [argument_name: stage.name, argument_value: [""Development""]], [argument_name: limit, argument_value: 10])), 
+- (tool_name: summarize_objects, arguments= ([argument_name: objects, argument_value: $$PREV[0]))]"
+Query: List all tickets owned by user Bob Smith in the Customer Support stage where the work item needs a response and provide a summary of these tickets.,"For this task, we need to list and summarize all tickets owned by ""Bob Smith"" in the ""Customer Support"" stage that need a response. We will use the following sequence of APIs and arguments:
+
+1. **API Call:** `works_list`
+   - **Arguments:**
+     - `(owned_by, [""Bob Smith""])`: To filter tickets owned by Bob Smith.
+     - `(stage.name, [""Customer Support""])`: To filter tickets in the Customer Support stage.
+     - `(ticket.needs_response, true)`: To filter tickets that need a response.
+     - `(type, [""ticket""])`: To specify that we are looking for tickets.
+
+2. **API Call:** `summarize_objects`
+   - **Arguments:**
+     - `(objects, $$PREV[0])`: To summarize the tickets retrieved from the previous API call.
+
+The sequence of API calls and arguments would be:
+1. `[(tool_name: works_list, arguments: [ (argument_name: owned_by, argument_value: [""Bob Smith""]), (argument_name: stage.name, argument_value: [""Customer Support""]), (argument_name: ticket.needs_response, argument_value: true), (argument_name: type, argument_value: [""ticket""])])],`
+2. `[(tool_name: summarize_objects, arguments: [(argument_name: objects, argument_value: $$PREV[0])])]`
+
+This sequence will first retrieve the relevant tickets and then provide a summary of them."
+"Query: Filter out work items associated with Rev organizations ""Apache""  and ""Nvidia,"" which do not need a response and generate a summary for them. Using this summary, create actions from them and add them to my current sprint.","To solve this task, we need to perform several steps using the given APIs:
+
+1. **Filter work items associated with Rev organizations ""Apache"" and ""Nvidia"" which do not need a response:** 
+   - We will use the `works_list` API with the following arguments:
+     - `(ticket.rev_org, [""Apache"", ""Nvidia""])` to filter by the specified Rev organizations.
+     - `(ticket.needs_response, false)` to filter out tickets that do not need a response.
+
+2. **Generate a summary of these filtered work items:** 
+   - We will then use the `summarize_objects` API with the argument:
+     - `(objects, $$PREV[0])` to summarize the objects obtained from the previous API call.
+
+3. **Create actions from the generated summary:** 
+   - Next, we call the `create_actionable_tasks_from_text` API with the argument:
+     - `(text, $$PREV[1])` to create tasks based on the summary text from the previous step.
+
+4. **Add these actions to the current sprint:** 
+   - To accomplish this, we first need to get the ID of the current sprint using the `get_sprint_id` API with no arguments.
+   - Then, we use the `add_work_items_to_sprint` API with the following arguments:
+     - `(work_ids, $$PREV[2])` to add the work items (tasks) created in the previous step.
+     - `(sprint_id, $$PREV[3])` to specify the current sprint ID obtained from the `get_sprint_id` API.
+
+Therefore, the answer is:
+- [(tool_name: works_list, arguments: [(argument_name: ticket.rev_org, argument_value: [""Apache"", ""Nvidia""]), (argument_name: ticket.needs_response, argument_value: false)]),
+- (tool_name: summarize_objects, arguments: [(argument_name: objects, argument_value: $$PREV[0])]),
+- (tool_name: create_actionable_tasks_from_text, arguments: [(argument_name: text, argument_value: $$PREV[1])]),
+- (tool_name: get_sprint_id, arguments: []),
+- (tool_name: add_work_items_to_sprint, arguments: [(argument_name: work_ids, argument_value: $$PREV[2]), (argument_name: sprint_id, argument_value: $$PREV[3])])]"
+"Query: Find and summarize any urgent issues related to my project ""Gladeus""?","To find and summarize any urgent issues related to the project ""Gladeus"", we need to perform a series of API calls:
+
+1. **who_am_i:** First, we need to identify the user making the request. This step is crucial as it ensures that the subsequent actions are tailored to the specific user.
+   - Arguments: None
+
+2. **works_list:** After identifying the user, we need to retrieve a list of work items that match the specified criteria, in this case, urgent issues related to the project ""Gladeus"".
+   - Arguments:
+     - `owned_by`: To filter work items owned by the user identified in the first step. Argument value: `$$PREV[0]` (ID of the current user).
+     - `applies_to_part`: To filter work items related to the project ""Gladeus"". Argument value: ""Gladeus"".
+     - `issue.priority`: To filter issues by urgency. Argument value: [""p0""] (assuming p0 indicates the highest priority).
+
+3. **summarize_objects:** After retrieving the list of urgent issues related to ""Gladeus"", we need to summarize this list to provide a concise overview.
+   - Arguments:
+     - `objects`: The list of urgent issues related to ""Gladeus"" obtained from the previous API call. Argument value: `$$PREV[1]`.
+
+Therefore, the solution is:
+1. [(tool_name: who_am_i, arguments: [])],
+2. [(tool_name: works_list, arguments: [(argument_name: owned_by, argument_value: $$PREV[0]), (argument_name: applies_to_part, argument_value: ""Gladeus""), (argument_name: issue.priority, argument_value: [""p0""])]),
+3. [(tool_name: summarize_objects, arguments: [(argument_name: objects, argument_value: $$PREV[1])])]."
+Query: Identify and generate a summary of high-severity tickets originating from 'Slack' by customers with the tag 'VIP'.,"To solve this task, we need to identify high-severity tickets originating from 'Slack' and tagged as 'VIP' and then generate a summary of these tickets. Here's how we can achieve this using the given APIs:
+
+1. **Call the `works_list` API** to retrieve a list of work items that match our criteria. We need to use the following arguments:
+   - `ticket.severity` with the argument value `high` to filter tickets by high severity.
+   - `ticket.source_channel` with the argument value `Slack` to filter tickets originating from Slack.
+   - `ticket.rev_org` with a placeholder value `$$PREV[0]` which will be determined in the next step.
+
+2. **Before calling `works_list`, we need to identify the Rev organization ID for customers tagged as 'VIP'**. For this, we use the `search_object_by_name` API with the following arguments:
+   - `query` with the argument value `VIP` to search for the Rev organization ID associated with VIP customers.
+
+3. **Finally, call the `summarize_objects` API** to summarize the list of tickets obtained. We use the following argument:
+   - `objects` with the argument value `$$PREV[1]` to summarize the tickets obtained from the `works_list` call.
+
+Therefore, the answer is:
+1. [(tool_name: search_object_by_name, argument_name: query, argument_value: VIP),
+2. (tool_name: works_list, arguments: [(argument_name: ticket.severity, argument_value: high), (argument_name: ticket.source_channel, argument_value: Slack), (argument_name: ticket.rev_org, argument_value: $$PREV[0])]),
+3. (tool_name: summarize_objects, arguments: [(argument_name: objects, argument_value: $$PREV[1])])]."
+Query: Find all tasks created by me and generate a summary. Add the summarized tasks to the current sprint.,"To solve this task, we need to follow these steps:
+
+1. **Identify the User**: Since the tasks need to be filtered by the ones created by the user, we first need to identify the user. We'll use the `who_am_i` API for this purpose.
+
+2. **List the Tasks Created by the User**: Next, we need to retrieve all tasks that were created by the user. We'll use the `works_list` API with the arguments:
+   - `created_by` set to the result of the `who_am_i` API to filter tasks created by the user.
+   - `type` set to ""task"" since we are only interested in tasks.
+
+3. **Summarize the Tasks**: Once we have the list of tasks, we need to summarize them. We'll use the `summarize_objects` API with the `objects` argument set to the result of the `works_list` API.
+
+4. **Get the Current Sprint ID**: To add these tasks to the current sprint, we first need to know the ID of the current sprint. We use the `get_sprint_id` API for this.
+
+5. **Add Summarized Tasks to the Sprint**: Finally, we'll use the `add_work_items_to_sprint` API with the arguments:
+   - `work_ids` set to the result of the `summarize_objects` API.
+   - `sprint_id` set to the result of the `get_sprint_id` API.
+
+Therefore, the answer is:
+1. `[(tool_name: who_am_i, arguments: [])]`
+2. `[(tool_name: works_list, arguments: [(argument_name: created_by, argument_value: $$PREV[0]), (argument_name: type, argument_value: task)])]`
+3. `[(tool_name: summarize_objects, arguments: [(argument_name: objects, argument_value: $$PREV[1])])]`
+4. `[(tool_name: get_sprint_id, arguments: [])]`
+5. `[(tool_name: add_work_items_to_sprint, arguments: [(argument_name: work_ids, argument_value: $$PREV[2]), (argument_name: sprint_id, argument_value: $$PREV[3])])]`"
+Query: Get the ID of the current sprint and add all tasks assigned to user DEVU-789 to it.,"To solve this task, we need to perform a series of API calls in sequence. The first step is to identify the current sprint, which we can achieve by using the `get_sprint_id` API. This API does not require any arguments.
+
+Next, we need to find all tasks assigned to the user ""DEVU-789"". For this, we will use the `works_list` API. The relevant arguments for this API are `owned_by` (to filter tasks assigned to ""DEVU-789"") and `type` (to filter for tasks only). 
+
+Finally, we need to add these tasks to the current sprint. We will use the `add_work_items_to_sprint` API for this, where `work_ids` will be the list of tasks we found, and `sprint_id` will be the ID of the current sprint we obtained earlier.
+
+Therefore, the answer is:
+
+1. Call `get_sprint_id` API (No arguments needed).
+2. Call `works_list` API with the arguments:
+   - `owned_by`: ""DEVU-789""
+   - `type`: ""task""
+3. Call `add_work_items_to_sprint` API with the arguments:
+   - `work_ids`: $$PREV[1]
+   - `sprint_id`: $$PREV[0]"

Updated_API_list.json

@@ -0,0 +1 @@
+[{"name": "works_list", "description": "Returns a list of work items matching the request.", "arguments": [{"argument_name": "applies_to_part", "argument_description": "Filters for work belonging to any of the provided parts", "argument_type": "array of strings"}, {"argument_name": "created_by", "argument_description": "Filters for work created by any of these users", "argument_type": "array of strings"}, {"argument_name": "issue.priority", "argument_description": "Filters for issues with any of the provided priorities. Allowed values: p0, p1, p2, p3", "argument_type": "array of strings"}, {"argument_name": "issue.rev_orgs", "argument_description": "Filters for issues with any of the provided Rev organizations", "argument_type": "array of strings"}, {"argument_name": "limit", "argument_description": "The maximum number of works to return. The default is '50'", "argument_type": "integer (int32)"}, {"argument_name": "owned_by", "argument_description": "Filters for work owned by any of these users", "argument_type": "array of strings"}, {"argument_name": "ticket.needs_response", "argument_description": "Filters for tickets that need a response", "argument_type": "boolean"}, {"argument_name": "ticket.rev_org", "argument_description": "Filters for tickets associated with any of the provided Rev organizations", "argument_type": "array of strings"}, {"argument_name": "ticket.severity", "argument_description": "Filters for tickets with any of the provided severities. Allowed values: blocker, high, low, medium", "argument_type": "array of strings"}, {"argument_name": "ticket.source_channel", "argument_description": "Filters for tickets with any of the provided source channels", "argument_type": "array of strings"}, {"argument_name": "type", "argument_description": "Filters for work of the provided types. Allowed values: issue, ticket, task", "argument_type": "array of strings"}, {"argument_name": "date_of_creation", "argument_description": "Filters for the date of creation of the work item. Allowed format: yyyy-MM-dd HH:mm:ss"}, {"argument_name": "last_modified", "argument_description": "Filters for work items last modified since a specified date. Allowed format: yyyy-MM-dd HH:mm:ss"}, {"argument_name": "target_close_date", "argument_description": "Filter for the timestamp for when the work is expected to be complete. Allowed format: yyyy-MM-dd HH:mm:ss"}]}, {"name": "summarize_objects", "description": "Summarizes a list of objects. The logic of how to summarize a particular object type is an internal implementation detail.", "arguments": [{"argument_name": "objects", "argument_description": "List of objects to summarize", "argument_type": "array of objects"}]}, {"name": "prioritize_objects", "description": "Returns a list of objects sorted by priority. The logic of what constitutes priority for a given object is an internal implementation detail.", "arguments": [{"argument_name": "objects", "argument_description": "A list of objects to be prioritized", "argument_type": "array of objects"}]}, {"name": "add_work_items_to_sprint", "description": "Adds the given work items to the sprint", "arguments": [{"argument_name": "work_ids", "argument_description": "A list of work item IDs to be added to the sprint.", "argument_type": "array of strings"}, {"argument_name": "sprint_id", "argument_description": "The ID of the sprint to which the work items should be added", "argument_type": "string"}]}, {"name": "get_sprint_id", "description": "Returns the ID of the current sprint", "arguments": []}, {"name": "get_similar_work_items", "description": "Returns a list of work items that are similar to the given work item", "arguments": [{"argument_name": "work_id", "argument_description": "The ID of the work item for which you want to find similar items", "argument_type": "string"}]}, {"name": "search_object_by_name", "description": "Given a search string, returns the id of a matching object in the system of record. If multiple matches are found, it returns the one where the confidence is highest.", "arguments": [{"argument_name": "query", "argument_description": "The search string, could be for example customer's name, part name, username.", "argument_type": "string"}]}, {"name": "create_actionable_tasks_from_text", "description": "Given a text, extracts actionable insights, and creates tasks for them, which are kind of a work item.", "arguments": [{"argument_name": "text", "argument_description": "The text from which the actionable insights need to be created.", "argument_type": "string"}]}, {"name": "who_am_i", "description": "Returns the ID of the current user", "arguments": []}, {"name": "is_empty", "description": "Checks if a given list is empty and returns one of two lists based on the result.", "arguments": [{"argument_name": "list_to_check", "argument_description": "The list to be checked for emptiness.", "argument_type": "array"}, {"argument_name": "options", "argument_description": "Two lists of objects. Returns the first one if the list_to_check is empty, otherwise returns the second one.", "argument_type": "array of arrays"}]}, {"name": "count", "description": "Returns the number of work items in the output of an API call.", "arguments": [{"argument_name": "objects", "argument_description": "A list of objects to be counted.", "argument_type": "array of objects"}]}, {"name": "works-create", "description": "Creates work items based on the provided parameters.", "arguments": [{"argument_name": "applies_to_part", "argument_description": "The part that the work applies to. Specifying a part is required when creating tickets and issues. Note: REQUIRED", "argument_type": "array of strings"}, {"argument_name": "created_by", "argument_description": "The users that reported the work", "argument_type": "array of strings"}, {"argument_name": "issue.priority", "argument_description": "The Priority of the work based upon impact and criticality. Allowed values: p0, p1, p2, p3", "argument_type": "string"}, {"argument_name": "developed_with", "argument_description": "The IDs of the parts associated with work item", "argument_type": "array of strings"}, {"argument_name": "owned_by", "argument_description": "The users that own the work. Note: REQUIRED", "argument_type": "array of strings"}, {"argument_name": "stage.name", "argument_description": "Sets an objects initial stage", "argument_type": "string"}, {"argument_name": "sprint", "argument_description": "The sprint that the issue belongs to", "argument_type": "string"}, {"argument_name": "type", "argument_description": "Type of the work item. Allowed values: issue, ticket, task. Note: REQUIRED", "argument_type": "string"}, {"argument_name": "target_close_date", "argument_description": "Timestamp for when the work is expected to be complete. Allowed format: yyyy-MM-dd HH:mm:ss", "argument_type": "date"}, {"argument_name": "title", "argument_description": "Title of the work object; Note: REQUIRED. Allowed values: issue, ticket", "argument_type": "string"}]}, {"name": "works-delete", "description": "Deletes a work item.", "arguments": [{"argument_name": "id", "argument_description": "The work's ID", "argument_type": "array of objects"}]}, {"name": "works-update", "description": "Updates a work item's information", "arguments": [{"argument_name": "id", "argument_description": "id of the work item to be updated. REQUIRED.", "argument_type": "array of strings"}, {"argument_name": "applies_to_part", "argument_description": "Updates the part(s) that the work item applies to.", "argument_type": "array of strings"}, {"argument_name": "created_by", "argument_description": "Sets the users that reported the work to the provided user IDs", "argument_type": "array of strings"}, {"argument_name": "owned_by", "argument_description": "Sets the owner IDs to the provided user IDs. This must not be empty", "argument_type": "array of strings"}, {"argument_name": "stage.name", "argument_description": "The updated name of the stage, otherwise unchanged if not set", "argument_type": "string"}, {"argument_name": "type", "argument_description": "Updates the type of the work item. Allowed values: issue, ticket, task", "argument_type": "string"}, {"argument_name": "target_close_date", "argument_description": "Updates the timestamp for when the work is expected to complete", "argument_type": "date"}, {"argument_name": "title", "argument_description": "Updated title of the work object, or unchanged if not provided", "argument_type": "string"}, {"argument_name": "priority", "argument_description": "Updates the priority of the work item. Allowed values: p0, p1, p2, p3", "argument_type": "string"}]}, {"name": "rev-orgs-create", "description": "Creates a Rev organization based on provided parameters.", "arguments": [{"argument_name": "description", "argument_description": "Description of the Rev organization", "argument_type": "string "}, {"argument_name": "display_name", "argument_description": "Name of the Rev organization", "argument_type": "string"}, {"argument_name": "environment", "argument_description": "The environment of the Org. Defaults to 'production' if not specified.", "argument_type": "string"}]}, {"name": "rev-orgs-delete", "description": "Deletes a Rev organization.", "arguments": [{"argument_name": "id", "argument_description": "Id of the Rev organization to be deleted", "argument_type": "string "}]}, {"name": "rev-orgs-update", "description": "Creates a Rev organization based on provided parameters.", "arguments": [{"argument_name": "description", "argument_description": "Description of the Rev organization", "argument_type": "string "}, {"argument_name": "display_name", "argument_description": "Name of the Rev organization", "argument_type": "string"}, {"argument_name": "environment", "argument_description": "The environment of the Org. Defaults to 'production' if not specified.", "argument_type": "string"}, {"argument_name": "id", "argument_description": "The ID of Rev organization to update.", "argument_type": "string"}]}, {"name": "get_works_id", "description": "Get's the work id of the input objects", "arguments": [{"argument_name": "objects", "argument_description": "List of objects to get ID of", "argument_type": "array of objects"}]}, {"name": "get_current_date", "description": "Get's the current date", "arguments": []}]

all_apis.py

@@ -0,0 +1,383 @@
+API_LIST = [
+    {
+        "name": "works_list",
+        "description": "Returns a list of work items matching the request.",
+        "arguments": [
+            {
+                "argument_name": "applies_to_part",
+                "argument_description": "Filters for work belonging to any of the provided parts",
+                "argument_type": "array of strings"
+            },
+            {
+                "argument_name": "created_by",
+                "argument_description": "Filters for work created by any of these users",
+                "argument_type": "array of strings"
+            },
+            {
+                "argument_name": "issue.priority",
+                "argument_description": "Filters for issues with any of the provided priorities. Allowed values: p0, p1, p2, p3",
+                "argument_type": "array of strings"
+            },
+            {
+                "argument_name": "issue.rev_orgs",
+                "argument_description": "Filters for issues with any of the provided Rev organizations",
+                "argument_type": "array of strings"
+            },
+            {
+                "argument_name": "limit",
+                "argument_description": "The maximum number of works to return. The default is '50'",
+                "argument_type": "integer (int32)"
+            },
+            {
+                "argument_name": "owned_by",
+                "argument_description": "Filters for work owned by any of these users",
+                "argument_type": "array of strings"
+            },
+            {
+                "argument_name": "stage.name",
+                "argument_description": "Filters for records in the provided stage(s) by name",
+                "argument_type": "array of strings"
+            },
+            {
+                "argument_name": "ticket.needs_response",
+                "argument_description": "Filters for tickets that need a response",
+                "argument_type": "boolean"
+            },
+            {
+                "argument_name": "ticket.rev_org",
+                "argument_description": "Filters for tickets associated with any of the provided Rev organizations",
+                "argument_type": "array of strings"
+            },
+            {
+                "argument_name": "ticket.severity",
+                "argument_description": "Filters for tickets with any of the provided severities. Allowed values: blocker, high, low, medium",
+                "argument_type": "array of strings"
+            },
+            {
+                "argument_name": "ticket.source_channel",
+                "argument_description": "Filters for tickets with any of the provided source channels",
+                "argument_type": "array of strings"
+            },
+            {
+                "argument_name": "type",
+                "argument_description": "Filters for work of the provided types. Allowed values: issue, ticket, task",
+                "argument_type": "array of strings"
+            },
+            {
+                "argument_name": "date_of_creation",
+                "argument_description": "Filters for the date of creation of the work item. Allowed format: yyyy-MM-dd HH:mm:ss"
+            },
+            {
+                "argument_name": "last_modified",
+                "argument_description": "Filters for work items last modified since a specified date. Allowed format: yyyy-MM-dd HH:mm:ss"
+            },
+            {
+                "argument_name": "target_close_date",
+                "argument_description": "Filter for the timestamp for when the work is expected to be complete. Allowed format: yyyy-MM-dd HH:mm:ss"
+            }
+        ]
+    },
+    {
+        "name": "summarize_objects",
+        "description": "Summarizes a list of objects. The logic of how to summarize a particular object type is an internal implementation detail.",
+        "arguments": [
+            {
+                "argument_name": "objects",
+                "argument_description": "List of objects to summarize",
+                "argument_type": "array of objects"
+            }
+        ]
+    },
+
+    {
+        "name": "prioritize_objects",
+        "description": "Returns a list of objects sorted by priority. The logic of what constitutes priority for a given object is an internal implementation detail.",
+        "arguments": [
+            {
+                "argument_name": "objects",
+                "argument_description": "A list of objects to be prioritized",
+                "argument_type": "array of objects"
+            }
+        ]
+    },
+    {
+        "name": "add_work_items_to_sprint",
+        "description": "Adds the given work items to the sprint",
+        "arguments": [
+            {
+                "argument_name": "work_ids",
+                "argument_description": "A list of work item IDs to be added to the sprint.",
+                "argument_type": "array of strings"
+            },
+            {
+                "argument_name": "sprint_id",
+                "argument_description": "The ID of the sprint to which the work items should be added",
+                "argument_type": "string"
+            }
+        ]
+    },
+    {
+        "name": "get_sprint_id",
+        "description": "Returns the ID of the current sprint",
+        "arguments": []
+    },
+    {
+        "name": "get_similar_work_items",
+        "description": "Returns a list of work items that are similar to the given work item",
+        "arguments": [
+            {
+                "argument_name": "work_id",
+                "argument_description": "The ID of the work item for which you want to find similar items",
+                "argument_type": "string"
+            }
+        ]
+    },
+    {
+        "name": "search_object_by_name",
+        "description": "Given a search string, returns the id of a matching object in the system of record. If multiple matches are found, it returns the one where the confidence is highest.",
+        "arguments": [
+            {
+                "argument_name": "query",
+                "argument_description": "The search string, could be for example customer's name, part name, username.",
+                "argument_type": "string"
+            }
+        ]
+    },
+    {
+        "name": "create_actionable_tasks_from_text",
+        "description": "Given a text, extracts actionable insights, and creates tasks for them, which are kind of a work item.",
+        "arguments": [
+            {
+                "argument_name": "text",
+                "argument_description": "The text from which the actionable insights need to be created.",
+                "argument_type": "string"
+            }
+        ]
+    },
+    {
+        "name": "who_am_i",
+        "description": "Returns the ID of the current user",
+        "arguments": []
+    },
+    {
+        "name": "is_empty",
+        "description": "Checks if a given list is empty and returns one of two lists based on the result.",
+        "arguments": [
+            {
+                "argument_name": "list_to_check",
+                "argument_description": "The list to be checked for emptiness.",
+                "argument_type": "array"
+            },
+            {
+                "argument_name": "options",
+                "argument_description": "Two lists of objects. Returns the first one if the list_to_check is empty, otherwise returns the second one.",
+                "argument_type": "array of arrays"
+            }
+        ]
+    },
+    {
+        "name": "count",
+        "description": "Returns the number of work items in the output of an API call.",
+        "arguments": [
+            {
+                "argument_name": "objects",
+                "argument_description": "A list of objects to be counted.",
+                "argument_type": "array of objects"
+            }
+        ]
+    },
+    {
+        "name": "works-create",
+        "description": "Creates work items based on the provided parameters.",
+        "arguments": [
+            {
+                "argument_name": "applies_to_part",
+                "argument_description": "The part that the work applies to. Specifying a part is required when creating tickets and issues. Note: REQUIRED",
+                "argument_type": "array of strings"
+            },
+            {
+                "argument_name": "created_by",
+                "argument_description": "The users that reported the work",
+                "argument_type": "array of strings"
+            },
+            {
+                "argument_name": "issue.priority",
+                "argument_description": "The Priority of the work based upon impact and criticality. Allowed values: p0, p1, p2, p3",
+                "argument_type": "string"
+            },
+            {
+                "argument_name": "developed_with",
+                "argument_description": "The IDs of the parts associated with work item",
+                "argument_type": "array of strings"
+            },
+            {
+                "argument_name": "owned_by",
+                "argument_description": "The users that own the work. Note: REQUIRED",
+                "argument_type": "array of strings"
+            },
+            {
+                "argument_name": "stage.name",
+                "argument_description": "Sets an objects initial stage",
+                "argument_type": "string"
+            },
+            {
+                "argument_name": "sprint",
+                "argument_description": "The sprint that the issue belongs to",
+                "argument_type": "string"
+            },
+            {
+                "argument_name": "type",
+                "argument_description": "Type of the work item. Allowed values: issue, ticket, task. Note: REQUIRED",
+                "argument_type": "string"
+            },
+            {
+                "argument_name": "target_close_date",
+                "argument_description": "Timestamp for when the work is expected to be complete. Allowed format: yyyy-MM-dd HH:mm:ss",
+                "argument_type": "date"
+            },
+            {
+                "argument_name": "title",
+                "argument_description": "Title of the work object; Note: REQUIRED. Allowed values: issue, ticket",
+                "argument_type": "string"
+            }
+        ]
+    },
+    {
+        "name": "works-delete",
+        "description": "Deletes a work item.",
+        "arguments": [
+            {
+                "argument_name": "id",
+                "argument_description": "The work's ID",
+                "argument_type": "array of objects"
+            }
+        ]
+    },
+    {
+        "name": "works-update",
+        "description": "Updates a work item's information",
+        "arguments": [
+            {
+                "argument_name": "id",
+                "argument_description": "id of the work item to be updated. REQUIRED.",
+                "argument_type": "array of strings"
+            },
+            {
+                "argument_name": "applies_to_part",
+                "argument_description": "Updates the part(s) that the work item applies to.",
+                "argument_type": "array of strings"
+            },
+            {
+                "argument_name": "created_by",
+                "argument_description": "Sets the users that reported the work to the provided user IDs",
+                "argument_type": "array of strings"
+            },
+            {
+                "argument_name": "owned_by",
+                "argument_description": "Sets the owner IDs to the provided user IDs. This must not be empty",
+                "argument_type": "array of strings"
+            },
+            {
+                "argument_name": "stage.name",
+                "argument_description": "The updated name of the stage, otherwise unchanged if not set",
+                "argument_type": "string"
+            },
+            {
+                "argument_name": "type",
+                "argument_description": "Updates the type of the work item. Allowed values: issue, ticket, task",
+                "argument_type": "string"
+            },
+            {
+                "argument_name": "target_close_date",
+                "argument_description": "Updates the timestamp for when the work is expected to complete",
+                "argument_type": "date"
+            },
+            {
+                "argument_name": "title",
+                "argument_description": "Updated title of the work object, or unchanged if not provided",
+                "argument_type": "string"
+            },
+            {
+                "argument_name": "priority",
+                "argument_description": "Updates the priority of the work item. Allowed values: p0, p1, p2, p3",
+                "argument_type": "string"
+            }
+        ]
+    },
+    {
+        "name": "rev-orgs-create",
+        "description": "Creates a Rev organization based on provided parameters.",
+        "arguments": [
+            {
+                "argument_name": "description",
+                "argument_description": "Description of the Rev organization",
+                "argument_type": "string "
+            },
+            {
+                "argument_name": "display_name",
+                "argument_description": "Name of the Rev organization",
+                "argument_type": "string"
+            },
+            {
+                "argument_name": "environment",
+                "argument_description": "The environment of the Org. Defaults to 'production' if not specified.",
+                "argument_type": "string"
+            }
+        ]
+    },
+    {
+        "name": "rev-orgs-delete",
+        "description": "Deletes a Rev organization.",
+        "arguments": [
+            {
+                "argument_name": "id",
+                "argument_description": "Id of the Rev organization to be deleted",
+                "argument_type": "string "
+            }
+        ]
+    },
+
+    {
+        "name": "rev-orgs-update",
+        "description": "Creates a Rev organization based on provided parameters.",
+        "arguments": [
+            {
+                "argument_name": "description",
+                "argument_description": "Description of the Rev organization",
+                "argument_type": "string "
+            },
+            {
+                "argument_name": "display_name",
+                "argument_description": "Name of the Rev organization",
+                "argument_type": "string"
+            },
+            {
+                "argument_name": "environment",
+                "argument_description": "The environment of the Org. Defaults to 'production' if not specified.",
+                "argument_type": "string"
+            },
+            {
+                "argument_name": "id",
+                "argument_description": "The ID of Rev organization to update.",
+                "argument_type": "string"
+            }
+        ]
+    },
+    {
+        "name": "get_works_id",
+        "description": "Get's the work id of the input objects",
+        "arguments": [
+            {
+                "argument_name": "objects",
+                "argument_description": "List of objects to get ID of",
+                "argument_type": "array of objects"
+            }
+        ]
+    },
+    {
+        "name": "get_current_date",
+        "description": "Get's the current date",
+        "arguments": []
+    }
+
+]

api_json_to_doc.py

@@ -0,0 +1,24 @@
+from all_apis import API_LIST
+
+# Function to convert JSON to documentation format
+def convert_json_to_doc(API_LIST):
+    documentation = ""
+    for idx, api in enumerate(API_LIST):
+        documentation += f"#### {idx+1}. {api['name']}\n"
+        documentation += f"- *API Description:* {api['description']}\n"
+        if api["arguments"]:
+            documentation += "- **Arguments:**\n"
+            for arg in api["arguments"]:
+                try:
+                    documentation += f"  - {arg['argument_name']}:\n"
+                except:
+                    pass
+                try:
+                    documentation += f"     - Argument Description: {arg['argument_description']}\n"
+                except:
+                    pass
+                try:
+                    documentation += f"     - Argument Type: {arg['argument_type']}\n"
+                except:
+                    pass
+    return documentation

app.py

@@ -0,0 +1,203 @@
+from imports import *
+from pipelines import *
+from hal_check import *
+from prompts import *
+from prompt_templates import * 
+from retrieval import *
+from all_apis import *
+from prompts import *
+from update_api_toolset import *
+from mem_check import *
+warnings.filterwarnings('ignore')
+
+# retrieval examples
+retrieval_loader = CSVLoader(file_path=r'Seed_Dataset.csv', source_column = 'QUERY')
+retrieval_data = retrieval_loader.load()
+retrieval_embeddings = HuggingFaceEmbeddings()
+
+if "available_tools" not in st.session_state:
+    st.session_state.available_tools = available_tools.copy()
+    
+if "available_arguments" not in st.session_state:
+    st.session_state.available_arguments = available_arguments.copy()
+    
+if "arg_allowed_values_dict" not in st.session_state:
+    st.session_state.arg_allowed_values_dict = arg_allowed_values_dict.copy()
+    
+if "args_in_list_dict" not in st.session_state:
+    st.session_state.args_in_list_dict = args_in_list_dict.copy()
+    
+if "api_list_updated" not in st.session_state:
+    st.session_state.api_list_updated = API_LIST.copy()
+
+if "retrieval_vector_db" not in st.session_state:
+    st.session_state.retrieval_vector_db = FAISS.from_documents(
+        documents=retrieval_data,
+        embedding=retrieval_embeddings,
+        )
+
+# Initialize session state for messages if not already present
+if "messages" not in st.session_state:
+    st.session_state.messages = []
+
+if "PAST_QUERY" not in st.session_state:
+    st.session_state.PAST_QUERY = "NO PAST QUERIES"
+    st.session_state.PAST_RESPONSE = "NO PAST RESPONSES"
+    st.session_state.PREV_QUERY = ""
+    st.session_state.PREV_RESPONSE = ""
+
+# Function to clear the session state variable
+def clear_api_list_updated():
+    st.session_state.api_list_updated = API_LIST.copy()
+    st.session_state.args_in_list_dict = args_in_list_dict.copy()
+    st.session_state.arg_allowed_values_dict = arg_allowed_values_dict.copy()
+    st.session_state.available_arguments = available_arguments.copy()
+    st.session_state.available_tools = available_tools.copy()
+    st.session_state.retrieval_vector_db = FAISS.from_documents(
+        documents=retrieval_data,
+        embedding=retrieval_embeddings,
+        )
+
+# file_path = r'Updated_API_list.json'
+
+# Page navigation
+st.sidebar.title("Navigation")
+page = st.sidebar.radio("Go to", ["Chatbot", "Tool Management", "API_LIST"])
+
+if page == "Chatbot":
+    # Chatbot UI Code
+    st.title("DevRev AI Agent")
+
+    # Display chat messages from history
+    for message in st.session_state.messages:
+        with st.chat_message(message["role"]):
+            st.markdown(message["content"])
+
+    # Accept user input
+    if prompt := st.chat_input("What is up?"):
+        print("okay")
+        st.session_state.messages.append({"role": "user", "content": prompt})
+        with st.chat_message("user"):
+            st.markdown(prompt)
+        print(f"User query: {prompt}")
+        query = prompt
+        with st.chat_message("assistant"):
+            message_placeholder = st.empty()
+            json_answer = pipeline(query, st.session_state.api_list_updated, st.session_state.available_tools, st.session_state.available_arguments, st.session_state.arg_allowed_values_dict, st.session_state.args_in_list_dict, st.session_state.retrieval_vector_db) # allowed args dict ka placeholder modify karna bacha
+            full_response = json_answer
+            try:
+                message_placeholder.json(full_response)
+            except:
+                message_placeholder.markdown(full_response)
+        st.session_state.messages.append({"role": "assistant", "content": full_response})
+
+elif page == "Tool Management":
+    print("TOOLS")
+    # Tool Management Code
+    st.title("API Tool Management")
+
+    # Load or initialize the API list in session state
+    if "api_list_updated" not in st.session_state:
+        st.session_state.api_list_updated = API_LIST
+    
+    # Button to trigger the clearing action
+    if st.button("Reset API list"):
+        clear_api_list_updated()
+
+    # Add a new tool
+    st.header("Add a New Tool")
+    with st.form("new_tool_form"):
+        new_tool_name = st.text_input("Tool Name")
+        new_tool_desc = st.text_area("Tool Description")
+        submitted = st.form_submit_button("Add Tool")
+        if submitted:
+            st.session_state.api_list_updated, st.session_state.available_tools, st.session_state.available_arguments = add_tool(st.session_state.api_list_updated, new_tool_name, new_tool_desc, st.session_state.available_tools, st.session_state.available_arguments, st.session_state.retrieval_vector_db)
+            st.success("Tool Added Successfully!")
+            
+    if st.session_state.api_list_updated:
+        selected_tool_name = st.selectbox("Select a tool", options=[tool["name"] for tool in st.session_state.api_list_updated])
+        selected_tool = next((tool for tool in st.session_state.api_list_updated if tool['name'] == selected_tool_name), None)
+
+    # Update or Delete Tools
+    st.header("Update or Delete Tools")
+    if selected_tool:
+        with st.form("update_delete_tool_form"):
+            st.write(f"Selected Tool: {selected_tool_name}")
+            new_name = st.text_input("New Name", value=selected_tool['name'])
+            new_description = st.text_area("New Description", value=selected_tool['description'])
+            update_button = st.form_submit_button("Update Tool")
+            delete_button = st.form_submit_button("Delete Tool")
+
+            if update_button:
+                st.session_state.api_list_updated, st.session_state.available_tools, st.session_state.available_arguments, st.session_state.arg_allowed_values_dict, st.session_state.args_in_list_dict = update_tool(st.session_state.api_list_updated, selected_tool_name, new_name, new_description, st.session_state.available_tools, st.session_state.available_arguments, st.session_state.arg_allowed_values_dict, st.session_state.args_in_list_dict, st.session_state.retrieval_vector_db)
+                st.success("Tool Updated Successfully!")
+
+            if delete_button:
+                st.session_state.api_list_updated, st.session_state.available_tools, st.session_state.available_arguments, st.session_state.arg_allowed_values_dict, st.session_state.args_in_list_dict, st.session_state.retrieval_vector_db = delete_tool(st.session_state.api_list_updated, selected_tool_name, st.session_state.available_tools, st.session_state.available_arguments, st.session_state.arg_allowed_values_dict, st.session_state.args_in_list_dict, st.session_state.retrieval_vector_db)
+                st.success("Tool Deleted Successfully!")
+
+    # Add a New Argument to a Tool
+    st.header("Add a New Argument to a Tool")
+    # if st.session_state.api_list_updated:  # Check if there are tools available
+    #     selected_tool_name = st.selectbox("Select a tool to add an argument", options=[tool["name"] for tool in st.session_state.api_list_updated])
+    if selected_tool:
+        with st.form("new_argument_form"):
+            new_arg_name = st.text_input("Argument Name")
+            new_arg_desc = st.text_area("Argument Description")
+            new_arg_allowed_values = st.text_area("Argument Allowed Values")
+            new_arg_type = st.text_input("Argument Type")
+            submitted_arg = st.form_submit_button("Add Argument")
+            if submitted_arg:
+                st.session_state.api_list_updated, st.session_state.available_arguments, st.session_state.arg_allowed_values_dict, st.session_state.args_in_list_dict= add_argument(st.session_state.api_list_updated, selected_tool_name, new_arg_name, new_arg_desc, new_arg_type, new_arg_allowed_values, st.session_state.available_arguments, st.session_state.arg_allowed_values_dict, st.session_state.args_in_list_dict, st.session_state.retrieval_vector_db)
+                arg_allowed_values_dict[f"{selected_tool_name}/{new_arg_name}"] = new_arg_allowed_values
+                st.success("Argument Added Successfully!")
+    else:
+        st.write("No tools available. Add a tool first.")
+
+
+    # Update or Delete Arguments
+    st.header("Update or Delete Arguments")
+    if selected_tool:
+        st.write(f"Selected Tool: {selected_tool_name}")
+        selected_arg_name = st.selectbox("Select an argument", options=[arg["argument_name"] for arg in selected_tool["arguments"]])
+        selected_arg = next((arg for arg in selected_tool['arguments'] if arg['argument_name'] == selected_arg_name), None)
+
+        if selected_arg:
+            with st.form("update_delete_arg_form"):
+                new_arg_name = st.text_input("New Argument Name", value=selected_arg['argument_name'])
+                new_arg_desc = st.text_area("New Argument Description", value=selected_arg['argument_description'])
+                if f"{selected_tool_name}/{selected_arg_name}" in arg_allowed_values_dict:    
+                    new_arg_allowed_values = st.text_area("New Argument Allowed Values", value=arg_allowed_values_dict[f"{selected_tool_name}/{selected_arg_name}"])
+                else:
+                    new_arg_allowed_values = st.text_area("New Argument Allowed Values")
+                new_arg_type = st.text_input("New Argument Type", value=selected_arg['argument_type'])
+                update_arg_button = st.form_submit_button("Update Argument")
+                delete_arg_button = st.form_submit_button("Delete Argument")
+
+                if update_arg_button:
+                    st.session_state.api_list_updated, st.session_state.available_arguments, st.session_state.arg_allowed_values_dict, st.session_state.args_in_list_dict = update_argument(st.session_state.api_list_updated, selected_tool_name, selected_arg_name, new_arg_name, new_arg_desc, new_arg_type, new_arg_allowed_values, st.session_state.available_arguments, st.session_state.arg_allowed_values_dict, st.session_state.args_in_list_dict, st.session_state.retrieval_vector_db)
+                    arg_allowed_values_dict[f"{selected_tool_name}/{new_arg_name}"] = new_arg_allowed_values
+                    st.success("Argument Updated Successfully!")
+
+                if delete_arg_button:
+                    st.session_state.api_list_updated, st.session_state.available_arguments, st.session_state.arg_allowed_values_dict, st.session_state.args_in_list_dict = delete_argument(st.session_state.api_list_updated, selected_tool_name, selected_arg_name, st.session_state.available_arguments, st.session_state.arg_allowed_values_dict, st.session_state.args_in_list_dict, st.session_state.retrieval_vector_db)
+                    st.success("Argument Deleted Successfully!")
+
+    # Delete Multiple Arguments
+    if selected_tool:
+        st.header("Delete Multiple Arguments from Tool")
+        all_arg_names = [arg["argument_name"] for arg in selected_tool["arguments"]]
+        selected_args_to_delete = st.multiselect("Select arguments to delete from the tool", options=all_arg_names)
+        if st.button("Delete Selected Arguments"):
+            st.session_state.api_list_updated, st.session_state.available_arguments, st.session_state.arg_allowed_values_dict, st.session_state.args_in_list_dict = delete_multiple_arguments(st.session_state.api_list_updated, selected_tool_name, selected_args_to_delete, st.session_state.available_arguments, st.session_state.arg_allowed_values_dict, st.session_state.args_in_list_dict, st.session_state.retrieval_vector_db)
+            st.success("Selected Arguments Deleted Successfully!")
+    
+    # Display the current API list
+    st.header("Current API List")
+    st.text(json.dumps(st.session_state.api_list_updated, indent=2))
+
+    with open(file_path, 'w') as file:
+        json.dump(st.session_state.api_list_updated, file)
+elif page == "API_LIST":
+    st.session_state.api_list_updated, st.session_state.available_tools, st.session_state.available_arguments, st.session_state.arg_allowed_values_dict, st.session_state.args_in_list_dict
+    st.write(len(st.session_state.retrieval_vector_db.docstore._dict))

hal_check.py

@@ -0,0 +1,377 @@
+import ast
+import re
+from collections import OrderedDict
+
+available_tools = [
+    "works_list",
+    "summarize_objects",
+    "prioritize_objects",
+    "add_work_items_to_sprint",
+    "get_sprint_id",
+    "get_similar_work_items",
+    "search_object_by_name",
+    "create_actionable_tasks_from_text",
+    "who_am_i",
+    "is_empty",
+    "count",
+    "works-create",
+    "works-delete",
+    "works-update",
+    "rev-orgs-create",
+    "rev-orgs-delete",
+    "rev-orgs-update",
+    "get_works_id",
+    "get_current_date"
+]
+available_arguments = [
+    "works_list/applies_to_part",
+    "works_list/created_by",
+    "works_list/issue.priority",
+    "works_list/issue.rev_orgs",
+    "works_list/limit",
+    "works_list/owned_by",
+    "works_list/stage.name",
+    "works_list/ticket.needs_response",
+    "works_list/ticket.rev_org",
+    "works_list/ticket.severity",
+    "works_list/ticket.source_channel",
+    "works_list/type",
+    "works_list/date_of_creation",
+    "works_list/last_modified",
+    "works_list/target_close_date",
+    "works_list/sprint",
+    "summarize_objects/objects",
+    "prioritize_objects/objects",
+    "add_work_items_to_sprint/work_ids",
+    "add_work_items_to_sprint/sprint_id",
+    "get_sprint_id/",
+    "get_similar_work_items/work_id",
+    "search_object_by_name/query",
+    "create_actionable_tasks_from_text/text",
+    "who_am_i/",
+    "is_empty/list_to_check",
+    "count/objects",
+    "works-create/applies_to_part",
+    "works-create/created_by",
+    "works-create/issue.priority",
+    "works-create/developed_with",
+    "works-create/owned_by",
+    "works-create/stage.name",
+    "works-create/sprint",
+    "works-create/type",
+    "works-create/target_close_date",
+    "works-create/title",
+    "works-delete/id",
+    "works-update/id",
+    "works-update/applies_to_part",
+    "works-update/created_by",
+    "works-update/owned_by",
+    "works-update/stage.name",
+    "works-update/type",
+    "works-update/target_close_date",
+    "works-update/title",
+    "works-update/priority",
+    "rev-orgs-create/description",
+    "rev-orgs-create/display_name",
+    "rev-orgs-create/environment",
+    "rev-orgs-delete/id",
+    "rev-orgs-update/description",
+    "rev-orgs-update/display_name",
+    "rev-orgs-update/environment",
+    "rev-orgs-update/id",
+    "get_works_id/objects",
+    "get_current_date/"
+]
+
+arg_allowed_values_dict = {'works-update/priority': ['p0', 'p1', 'p2', 'p3'],
+ 'works-update/type': ['issue', 'task', 'ticket'],
+ 'works_list/issue.priority': ['p0', 'p1', 'p2', 'p3'],
+ 'works_list/ticket.needs_response': ['true', 'false'],
+ 'works_list/ticket.severity': ['blocker', 'low', 'medium', 'high'],
+ 'works_list/type': ['issue', 'task', 'ticket'],
+ 'works-create/issue.priority': ['p0', 'p1', 'p2', 'p3'],
+ 'works-create/type': ['issue', 'task', 'ticket'],
+ 'works-create/title': ['issue', 'ticket']}
+
+args_in_list_dict = {
+ 'works_list/applies_to_part': 1,
+ 'works_list/created_by': 1,
+ 'works_list/issue.priority': 1,
+ 'works_list/issue.rev_orgs': 1,
+ 'works_list/limit': 0,
+ 'works_list/owned_by': 1,
+ 'works_list/stage.name': 1,
+ 'works_list/ticket.needs_response': 0,
+ 'works_list/ticket.rev_org': 1,
+ 'works_list/ticket.severity': 1,
+ 'works_list/ticket.source_channel': 1,
+ 'works_list/type': 1,
+ 'works_list/date_of_creation': 0,
+ 'works_list/last_modified': 0,
+ 'works_list/target_close_date': 0,
+ 'works_list/sprint': 1,
+ 'summarize_objects/objects': 1,
+ 'prioritize_objects/objects': 1,
+ 'add_work_items_to_sprint/work_ids': 1,
+ 'add_work_items_to_sprint/sprint_id': 0,
+ 'get_similar_work_items/work_id': 0,
+ 'search_object_by_name/query': 0,
+ 'create_actionable_tasks_from_text/text': 0,
+ 'is_empty/list_to_check': 0,
+ 'count/objects': 1,
+ 'works-create/applies_to_part': 1,
+ 'works-create/created_by': 1,
+ 'works-create/issue.priority': 1,
+ 'works-create/developed_with': 1,
+ 'works-create/owned_by': 1,
+ 'works-create/stage.name': 1,
+ 'works-create/sprint': 1,
+ 'works-create/type': 1,
+ 'works-create/target_close_date': 0,
+ 'works-create/title': 0,
+ 'works-delete/id': 1,
+ 'works-update/id': 1,
+ 'works-update/applies_to_part': 1,
+ 'works-update/created_by': 1,
+ 'works-update/owned_by': 1,
+ 'works-update/stage.name': 1,
+ 'works-update/type': 1,
+ 'works-update/target_close_date': 0,
+ 'works-update/title': 0,
+ 'works-update/priority': 1,
+ 'rev-orgs-create/description': 0,
+ 'rev-orgs-create/display_name': 0,
+ 'rev-orgs-create/environment': 0,
+ 'rev-orgs-delete/id': 0,
+ 'rev-orgs-update/description': 0,
+ 'rev-orgs-update/display_name': 0,
+ 'rev-orgs-update/environment': 0,
+ 'rev-orgs-update/id': 0,
+ 'get_works_id/objects': 1,
+ 'get_current_date/': 0
+}
+
+
+def find_hallucinations(json_response, arg_allowed_values_dict, available_tools, available_arguments, args_in_list_dict):
+    # check errors in names of tools and arguments
+    for i, item in enumerate(json_response):
+        print(item)
+        if 'tool_name' not in item:
+            if type(item) is dict:
+                first_key = list(item.keys())[0]
+                first_value = item.pop(first_key)
+                # Create a new dictionary with 'tool_name' and the rest of the key-value pairs
+                new_item = {'tool_name': first_value, **item}
+                json_response[i] = new_item
+        else:
+            item = 'tool_name'
+
+    tool_names = [item['tool_name'] for item in json_response]
+    print(f"tool_names:{tool_names}")
+    print(f"available_tools:{available_tools}")
+    print(f"available_arguments:{available_arguments}")
+    valid_tools = [tool_name for tool_name in tool_names if tool_name in available_tools]
+    print(f"valid_tools:{valid_tools}")
+    hallucinated_tools = [tool_name for tool_name in tool_names if tool_name not in available_tools]
+    print(f"hallucinated_tools:{hallucinated_tools}")
+    argument_names = []
+
+    for item in json_response:
+        for key in item:
+            if item[key] in valid_tools:
+                # try:
+                arguments = item.get("arguments", [])
+                for argument in arguments:
+                    argument_name = argument.get("argument_name")
+                    if argument_name:
+                        argument_names.append(item["tool_name"]+"/"+argument_name)
+                # except AttributeError:
+                    # pass
+    # valid_args = [arg_name for arg_name in argument_names if arg_name in merged_arguments]
+    hallucinated_args = [arg_name for arg_name in argument_names if arg_name not in available_arguments]
+    # check the validity of argument values using allowed_arg_values_dict
+    json_args_dict = {}
+    for item in json_response:
+        for key in item:
+            if item[key] in available_tools:
+                # try:
+                arguments = item.get("arguments", [])
+                for argument in arguments:
+                    argument_name = argument.get("argument_name")
+                    if argument_name:
+                        json_args_dict[item["tool_name"]+"/"+argument_name] = argument["argument_value"]
+                        concat_arg = item["tool_name"] + "/" + argument_name
+                        argument_names.append(concat_arg)
+                        # try:
+                        if args_in_list_dict[concat_arg] == 1: ## fixes the arguments that are supposed to be in a list format but are not
+                            arg_val = argument.get("argument_value")
+                            if type(arg_val) is not list:
+                                l = []
+                                l.append(arg_val)
+                                argument["argument_value"] = l
+                #         except KeyError:
+                #             pass
+                # except AttributeError:
+                #     pass
+
+    hallucinated_args_values_prev = []
+    for idx, item in enumerate(json_response):
+        for key in item:
+            if item[key] in available_tools:
+                # try:
+                arguments = item.get("arguments", [])
+                for argument in arguments:
+                    argument_name = argument.get("argument_name")
+
+                    if argument_name:
+                        json_args_dict[item["tool_name"]+"/"+argument_name] = argument["argument_value"]
+                        # print("argument value ", argument['argument_value'])
+                        # try:
+                        print("argument value", argument['argument_value'])
+                        arg_list = ast.literal_eval(argument['argument_value'])
+                        for arg in arg_list:
+                                # print("arument 2, ", arg)
+                            if ("$$PREV" in arg and int(arg.split("[")[1].split("]")[0])):
+                                hallucinated_args_values_prev.append((item["tool_name"] + "/" + argument_name, arg))
+                #         except:
+                #             pass
+                # except AttributeError:
+                #     pass
+
+    hallucinated_args_values = []
+    for arg_name, arg_value in json_args_dict.items():
+        if arg_name in arg_allowed_values_dict:
+            if type(arg_value) is not list:
+                if arg_value not in arg_allowed_values_dict[arg_name]:
+                    hallucinated_args_values.append((arg_name, arg_value))
+            else:
+                for i in arg_value:
+                    if i not in arg_allowed_values_dict[arg_name]:
+                        hallucinated_args_values.append((arg_name, i))
+    return hallucinated_args, hallucinated_tools, hallucinated_args_values, hallucinated_args_values_prev
+
+def correction(hallucinated_args, hallucinated_args_values, hallucinated_tools, hallucinated_args_values_prev, json_response):
+  Correction_prompt = ''
+  Correction_prompt += f'These are the following errors in your previous json response \n {json_response} \n'
+  for i in hallucinated_args:
+    Correction_prompt += f"The argument {i} is used but is not present in the provided API list. \n"
+  for i in hallucinated_tools:
+    Correction_prompt += f"The tool {i} is used but is not present in the provided API list. \n"
+  for i, j in hallucinated_args_values:
+    Correction_prompt += f"Argument_value '{j}' for argument '{i}' is not valid according to the specified API list. \n"
+  for i, j in hallucinated_args_values_prev:
+    Correction_prompt += f"Argument_value '{j}' for argument '{i}' is not valid since it refers to an item in the API list that does not come before it.\n"
+  Correction_prompt += "You have to give the corrected solution to the product manager's query by modifying the provided JSON. You have to remove hallucinations and only output the corrected JSON. \n"
+  return Correction_prompt
+
+def correction_if_wrong_schema(exception, json_response):
+    Correction_prompt = 'The json you extracted in your response does not follow the appropriate json schema' + '\n'
+    Correction_prompt += f'Upon extracting your json response : \n {json_response} \n'
+    Correction_prompt += f'The following error is encountered : {exception}' + '\n'
+    Correction_prompt += "You have to give the corrected solution to the product manager's query by modifying the provided JSON. You have to remove the error and only output the corrected JSON."
+    return Correction_prompt
+
+def placeholder_check(json_response):
+    argument_names = []
+    if type(json_response) is dict:
+        l = []
+        l.append(json_response)
+        json_response = l
+    for item in json_response:
+        # try:
+        arguments = item.get("arguments", [])
+        for argument in arguments:
+            # try:
+                argument_name = argument.get("argument_name", [])
+                argument_value = argument["argument_value"]
+                x = re.search("<.*>", str(argument_value))
+                if x:
+                    return 1
+        #         except KeyError:
+        #             return 1
+        # except AttributeError:
+        #     return 0
+    return 0
+
+
+def unsolvable_check(json_response):
+    for item in json_response:
+        for key in item:
+            if type(item[key]) is list:
+                return 0
+            arg = item[key]
+            x = re.search(".*cannot.*", arg)
+            if x:
+                return 1
+    return 0
+
+def complexity(output):
+    num_tools = 0
+    num_args = 0
+    tool_wt = 2
+    args_wt = 0.5
+    for tool in output:
+        num_tools += 1
+        arguments = tool.get("arguments", [])
+        for argument in arguments:
+            num_args += 1
+    return num_args*args_wt + num_tools*tool_wt
+
+def structure_check(json_response):
+    if type(json_response) is dict:
+        l = []
+        l.append(json_response)
+        json_response = l
+    for i, item in enumerate(json_response):        #fixing tool_name issue
+        if 'tool_name' not in item:
+            if type(item) is dict:
+                first_key = list(item.keys())[0]
+                first_value = item.pop(first_key)
+                # Create a new dictionary with 'tool_name' and the rest of the key-value pairs
+                new_item = {'tool_name': first_value, **item}
+                json_response[i] = new_item
+        else:
+            item = 'tool_name'
+
+
+    restructured_json = []
+    for item in json_response:
+        d = {}
+        d['tool_name'] = item['tool_name']
+        x=[]
+        try:
+            for args in item['arguments']:
+                d_ = {}
+                d_['argument_name'] = args['argument_name']
+                d_['argument_value'] = args['argument_value']
+                x.append(d_)
+            d['arguments'] = x
+            restructured_json.append(d)
+        except (KeyError, TypeError) as e:
+            if 'arguments' in item:
+                if type(item['arguments']) is not list:
+                    x = []
+                    x.append(item['arguments'])
+                    item['arguments'] = x
+                # print(item['arguments'])]
+
+                for args in item['arguments']:
+                    # print(args)
+                    x_ = []
+                    n = {}
+                    keys = list(args.keys())
+                    # print(keys)
+                    for j in keys:
+                        d_ = {}
+                        d_['argument_name'] = j
+                        d_['argument_value'] = item['arguments'][0][j]
+                        # print(d_)
+                        x_.append(d_)
+                    n['tool_name'] = item['tool_name']
+                    n['arguments'] = x_
+                    restructured_json.append(n)
+                else:
+                    pass
+
+    print(restructured_json)
+    return restructured_json

imports.py

@@ -0,0 +1,20 @@
+import streamlit as st
+import json
+import os
+import time
+import random
+import warnings
+import simplejson as json
+import pandas as pd
+import re
+import ast
+from langchain.prompts import PromptTemplate
+from langchain.chains import LLMChain
+from langchain.memory import ConversationBufferWindowMemory
+from langchain_community.chat_models import ChatOpenAI
+from langchain_community.llms import HuggingFaceHub
+from langchain_community.document_loaders import CSVLoader
+from langchain_huggingface import HuggingFaceEmbeddings
+from langchain_community.vectorstores import FAISS
+from langchain.schema.document import Document
+from langfuse.callback import CallbackHandler

mem_check.py

@@ -0,0 +1,12 @@
+from imports import *
+
+# Function to verify follow-up queries
+
+def verify_follow_up_query(mem_response):
+
+    classification_index = mem_response.find("Classification:")
+    extracted_part = mem_response[classification_index:].split("\n", 1)[0]
+    extracted_text = extracted_part.replace("Classification:", "").strip()
+    if(extracted_text=="Follow-up"):
+       return True
+    return False

pipelines.py

@@ -0,0 +1,201 @@
+from imports import *
+from hal_check import *
+from prompt_templates import *
+from api_json_to_doc import *
+from mem_check import *
+
+
+
+def dynamic_k(query):
+  word_count = len(query.split())
+  if word_count <= 7:
+    k = 1
+  elif word_count <= 15:
+    k = 2
+  else:
+    k = 3
+  return k
+
+def pipeline(query, API_LIST, available_tools, available_arguments, arg_allowed_values_dict, args_in_list_dict, vector_db):
+  print(f"PreviousQuery: {st.session_state.PREV_QUERY}")
+  print(f"PreviousResponse: {st.session_state.PREV_RESPONSE}")
+  print(f"PastQuery: {st.session_state.PAST_QUERY}")
+  print(f"PastResponse: {st.session_state.PAST_RESPONSE}")
+  API_LIST = convert_json_to_doc(API_LIST)
+  done = False
+  max_reprompts = 1
+  cntr = 1
+  num_examples = dynamic_k(query)
+  docs = vector_db.max_marginal_relevance_search(query, k = num_examples)
+  RAG_examples = ''
+  for i in range(num_examples):
+    RAG_examples += f'{docs[i].page_content}' + '\n'
+  classification = False
+  if(st.session_state.PREV_QUERY!=""):
+    if(st.session_state.PAST_QUERY=="NO PAST QUERIES"):
+      mem_resp = mem_chain.run(QUERY = query, PREV_QUERY = st.session_state.PREV_QUERY)
+    else:
+      mem_resp = mem_chain.run(QUERY = query, PREV_QUERY = st.session_state.PAST_QUERY)
+
+    print(f"0. Memory output- {cntr} ##################")
+    print(mem_resp)
+    print(f"##################")
+    classification = verify_follow_up_query(mem_resp)
+    if(classification==False):
+      st.session_state.PAST_QUERY = "NO PAST QUERIES"
+      st.session_state.PAST_RESPONSE = "NO PAST RESPONSES"
+      try:
+        resp1 = query_chain.run(QUERY = query , API_LIST = API_LIST, RAG = RAG_examples)
+      except:
+        return []
+      print(f"1. Pseudo code output- {cntr} ##################")
+      print(resp1)
+      print(type(resp1))
+      print(len(resp1))
+      print(f"##################")
+      
+    
+    else:
+      if(st.session_state.PAST_RESPONSE =="NO PAST RESPONSES"):
+        st.session_state.PAST_QUERY = st.session_state.PREV_QUERY
+        st.session_state.PAST_RESPONSE = st.session_state.PREV_RESPONSE
+      try:
+        resp2 = query_chain_memory.run(QUERY = query , API_LIST = API_LIST, RAG = RAG_examples, PAST_QUERY= st.session_state.PAST_QUERY, PAST_RESPONSE = st.session_state.PAST_RESPONSE)
+      except:
+        return resp1
+      print(f"1. Pseudo code output- {cntr} ##################")
+      print(resp2)
+      print(type(resp2))
+      print(len(resp2))
+      print(f"##################")
+  
+  else:  
+    try:
+      resp3 = query_chain.run(QUERY = query , API_LIST = API_LIST, RAG = RAG_examples)
+    except:
+      return []
+    print(f"1. Pseudo code output- {cntr} ##################")
+    print(resp3)
+    print(type(resp3))
+    print(len(resp3))
+    print(f"##################")
+  # json_response = []
+  # try:
+  #   # Extract json via python code
+  #   pass
+  # except:
+  try:
+    # print(memory.load_memory_variables({})['chat_history'])
+    # chat_history_temp = memory.load_memory_variables({})['chat_history'][1]
+    # print(chat_history_temp)
+    # memory.load_memory_variables({})['chat_history'] = chat_history_temp
+    resp_formatted= format_chain.run(QUERY = "")
+  except:
+    try:
+      return resp3
+    except:
+      return resp2
+  print(f"2. JSON string output- {cntr} ##################")
+  print(resp_formatted)
+  print(type(resp_formatted))
+  print(len(resp_formatted))
+  print(f"##################")
+  print(f"Reprompt Number: {cntr} #################")
+
+  print(f"Response formatted:{resp_formatted}")
+  try:
+    json_response = ast.literal_eval(resp_formatted)
+  except Exception as e:
+    Correction_prompt = correction_if_wrong_schema(e, resp_formatted)
+    resp_formatted = reprompt_chain.run(QUERY=query, API_LIST=API_LIST, CORRECTION_PROMPT=Correction_prompt)
+    try:
+      json_response = ast.literal_eval(resp_formatted)
+    except:
+      return []
+  print(f"3. JSON decoded output- {cntr} ##################")
+  print(json_response)
+  print(type(json_response))
+  print(len(json_response))
+  print(f"##################")
+
+
+  json_response_init = json_response
+
+  try:
+    while not done:
+      # hall = True
+      try:
+        hallucinated_args, hallucinated_tools, hallucinated_args_values, hallucinated_args_values_prev = find_hallucinations(json_response, arg_allowed_values_dict, available_tools, available_arguments, args_in_list_dict)
+      except:
+        return json_response_init
+      print('##############')
+      print(f'wrong stuff : {hallucinated_args}, {hallucinated_tools}, {hallucinated_args_values}, {hallucinated_args_values_prev}')
+      print('#############')
+      if ((len(hallucinated_args) + len(hallucinated_tools) + len(hallucinated_args_values)) + len(hallucinated_args_values_prev) is 0 ):
+        if(st.session_state.PREV_QUERY ==""):
+          st.session_state.PREV_QUERY = query
+          st.session_state.PREV_RESPONSE = str(json_response)
+        else:
+          if(classification==True):
+            st.session_state.PAST_QUERY = st.session_state.PAST_QUERY + '.\n' + query
+            st.session_state.PAST_RESPONSE = st.session_state.PAST_RESPONSE + '.\n' + str(json_response)
+          st.session_state.PREV_QUERY = query
+          st.session_state.PREV_RESPONSE = str(json_response)
+        return json_response
+      if cntr>max_reprompts:
+          done=True
+      try:
+        Correction_prompt = correction(hallucinated_args, hallucinated_args_values, hallucinated_tools, hallucinated_args_values_prev, json_response)
+      except:
+        return json_response_init
+      print(f"4. Correction prompt- {cntr} ##################")
+      print(Correction_prompt)
+      print(type(Correction_prompt))
+      print(len(Correction_prompt))
+      print(f"##################")
+
+      json_response = reprompt_chain.run(QUERY = query, API_LIST = API_LIST, CORRECTION_PROMPT = Correction_prompt)
+      try:
+        json_response = ast.literal_eval(json_response)
+      except Exception as e:
+        Correction_prompt = correction_if_wrong_schema(e, json_response)
+        json_response = reprompt_chain.run(QUERY=query, API_LIST=API_LIST, CORRECTION_PROMPT=Correction_prompt)
+        try:
+          json_response = ast.literal_eval(json_response)
+        except:
+          return []
+      cntr+=1
+      print(f"4. JSON decoded output- {cntr} ##################")
+      print(json_response)
+      print(type(json_response))
+      print(len(json_response))
+      print(f"##################")
+      # json_response = structure_check(json_response)
+      if placeholder_check(json_response):
+        if(classification==True):
+          st.session_state.PAST_QUERY = st.session_state.PAST_QUERY + '.\n' + query
+          st.session_state.PAST_RESPONSE = st.session_state.PAST_RESPONSE + '.\n' + '[]'
+        st.session_state.PREV_QUERY = query
+        st.session_state.PREV_RESPONSE = '[]'
+        return []
+      
+      if unsolvable_check(json_response):
+        if(classification==True):
+          st.session_state.PAST_QUERY = st.session_state.PAST_QUERY + '.\n' + query
+          st.session_state.PAST_RESPONSE = st.session_state.PAST_RESPONSE + '.\n' + '[]'
+        st.session_state.PREV_QUERY = query
+        st.session_state.PREV_RESPONSE = '[]'
+        return []
+    
+    if(st.session_state.PREV_QUERY ==""):
+      st.session_state.PREV_QUERY = query
+      st.session_state.PREV_RESPONSE = str(json_response)
+    else:
+      if(classification==True):
+        st.session_state.PAST_QUERY = st.session_state.PAST_QUERY + '.\n' + query
+        st.session_state.PAST_RESPONSE = st.session_state.PAST_RESPONSE + '.\n' + str(json_response)
+      st.session_state.PREV_QUERY = query
+      st.session_state.PREV_RESPONSE = str(json_response)
+  except:
+    return json_response_init    
+  return json_response

prompt_templates.py

@@ -0,0 +1,70 @@
+from imports import *
+from prompts import *
+
+
+os.environ['HUGGINGFACEHUB_API_TOKEN'] = "<API>"
+os.environ['OPENAI_API_KEY'] = "<API>"
+# ENV_HOST = "https://cloud.langfuse.com"
+# ENV_SECRET_KEY = userdata.get('LF-SECRET')
+# ENV_PUBLIC_KEY = userdata.get('LF-PUBLIC')
+
+system_prompt_classifier = PromptTemplate(
+    input_variables=["QUERY", "PREV_QUERY"], template= system_prompt_classifier_template,
+    output_key="cassification"
+)
+
+system_memory_prompt = PromptTemplate(
+    input_variables=["QUERY", "API_LIST", "RAG", "PAST_QUERY", "PAST_RESPONSE"], template= system_prompt_memory_template
+)
+
+system_prompt = PromptTemplate(
+    input_variables=["QUERY", "API_LIST", "RAG"], template= system_prompt_template
+)
+
+follow_up_prompt = PromptTemplate(
+    input_variables=["QUERY", "chat_history"], template= follow_up_prompt_template
+)
+generation_prompt = PromptTemplate(
+    input_variables = ["API_LIST", "FEW_SHOT", "MODIFIED_ARG"],template = generation_prompt_template
+  )
+
+memory = ConversationBufferWindowMemory(
+    memory_key="chat_history", input_key = "QUERY", k = 1, 
+    return_messages=True
+)
+llm_gpt_3_5 = ChatOpenAI(temperature = 0.0, model =  "gpt-3.5-turbo-1106")
+llm_gpt_4 = ChatOpenAI(temperature = 0.0, model =  "gpt-4")
+
+mem_chain = LLMChain(llm=llm_gpt_3_5,
+                     prompt=system_prompt_classifier,
+                     memory = memory,
+                     verbose=True)
+
+query_chain_memory = LLMChain(llm=llm_gpt_3_5,
+                        prompt=system_memory_prompt,
+                        memory = memory,
+                        verbose=True)
+
+query_chain = LLMChain(llm=llm_gpt_3_5,
+                       prompt=system_prompt,
+                       memory = memory,
+                       verbose=True)
+
+format_chain = LLMChain(llm=llm_gpt_3_5,
+                        prompt=follow_up_prompt,
+                        memory = memory,
+                        verbose=True)
+
+generation_chain = LLMChain(llm= ChatOpenAI(temperature = 0.7, model =  "gpt-4"),
+                        prompt=generation_prompt,
+                        output_key = 'QUERY',
+                        verbose=False)
+reprompt = PromptTemplate(
+    input_variables=["QUERY", "API_LIST", "CORRECTION_PROMPT", "chat_history"], template= reprompt_template
+)
+
+reprompt_chain = LLMChain(llm=llm_gpt_4,
+                        prompt=reprompt,
+                        output_key = 'new_response',
+                        memory = memory,
+                        verbose=True)

prompts.py

@@ -0,0 +1,150 @@
+system_prompt_classifier_template = '''You are an AI Assistant that specializes in Agile Software Development and Product Management and your task is to assist product managers.\n
+
+Objective: Determine if the current user query is a follow-up to previous queries/conversation in a developer/product management context.\n
+
+Instructions:\n
+1. Analyze it in the context of the previous query (provided for reference)..\n
+2. Classify the current query as either a "Follow-up" or "New Query".\n
+3. Provide a brief explanation for your classification.\n\n
+
+
+Your Task:\n
+Previous Query: {PREV_QUERY}\n
+Current Query: {QUERY}\n
+Classification: [Follow-up/New Query]\n
+Explanation: [Your reasoning]
+'''
+
+system_prompt_memory_template = '''You are an AI Assistant that specializes in Agile Software Development and Product Management and your task is to assist product managers by providing a list of APIs that can solve the given task using only the APIs given below.\n
+
+Below is a list of APIs with their descriptions. Each API has a name, description and a set of arguments. Each argument has a name, description and type.\n\n
+
+LIST OF API BEGINS\n
+
+{API_LIST}
+\n
+
+LIST OF API ENDS\n\n
+
+Now in the following conversation, the product manager will ask you to implement certain tasks.\n
+Here are the previous queries and responses that the product manager has asked you to solve. To solve the current query and use for tools or arguments, you can extract any information from these past queries and responses.\n\n
+
+Previous Queries: {PAST_QUERY}\n
+Previous Corresponding Responses: {PAST_RESPONSE}\n\n
+
+Now, the final output by you, the AI assistant, should be an ordered list of zero or more API's and their corresponding arguments that are needed to solve the task.\n\b
+
+Keep in mind that:\n
+1. A task might require multiple APIs to be called.\n
+2. The output can use an API more than one time.\n
+3. Each API can have multiple arguments being used.\n
+4. To reference the value of the ith API in the list, use $$PREV[i] as argument value. i = 0, 1,  ..  j-1;  j = current API’s index in the list.\n
+5. To answer the current query, you may require infromation from the previous queries. Though, this may not always be the case.\n
+
+Also note that: If you cannot solve the task using the given set of functions, state explicitly that the given task can't be solved using the given set of APIs.\n\n
+EXAMPLES BEGIN
+
+{RAG}
+
+EXAMPLES END\n
+
+You can use the previous conversations to fill in the arguments of the current query. Though, you cannot refer to values in previous conversations using '$$PREV[I]'. You have to use them explicitly.\n
+
+Query : {QUERY}
+
+'''
+
+
+system_prompt_template = '''You are an AI Assistant that specializes in Agile Software Development and Product Management and your task is to assist product managers by providing a list of APIs that can solve the given task using only the APIs given below.\n
+
+Below is a list of APIs with their descriptions. Each API has a name, description and a set of arguments. Each argument has a name, description and type.\n\n
+
+LIST OF API BEGINS\n
+
+{API_LIST}
+\n
+
+LIST OF API ENDS\n
+
+Now in the following conversation, the product manager will ask you to implement certain tasks.\n
+
+The output by you, the AI assistant, should be an ordered list of zero or more API's and their corresponding arguments that are needed to solve the task.\n\n
+
+Keep in mind that:\n
+1. A task might require multiple APIs to be called.\n
+2. The output can use an API more than one time.\n
+3. Each API can have multiple arguments being used.\n
+4. To reference the value of the ith API in the list, use $$PREV[i] as argument value. i = 0, 1,  ..  j-1;  j = current API’s index in the list.\n
+
+Note that: If you cannot solve the task using the given set of functions, state explicitly that the given task can't be solved using the given set of APIs.\n\n
+
+EXAMPLES BEGIN\n
+
+{RAG}
+\n
+EXAMPLES END\n\n
+
+
+
+Query : {QUERY}
+
+'''
+
+follow_up_prompt_template = '''
+{chat_history}
+From your solution extract a list of JSONs. Return only the list of JSONs. 
+The format for the JSONs:
+{{
+"tool_name": {{ "type": "string" }},
+"arguments": [
+{{
+"argument_name": "{{ "type": "string" }},
+"argument_value": {{ "type": "string" }},
+}}
+]
+}}
+
+If according to your response, the query cannot be solved using the given APIs, return an empty list.
+'''
+
+reprompt_template= '''You are an AI Assistant that specializes in Agile Software Development and Product Management and your task is to assist product managers by providing a list of APIs that can solve the given task using only the APIs given below.
+
+Below is a list of API's with their descriptions. Each API is represented as a dictionary with key value pairs where the keys are “name”, “description”, “arguments”. The value corresponding to the “arguments” key is a list of dictionaries where each dictionary represents an argument. Each argument is represented in the form of a dictionary with key value pairs where the keys are "argument name", "argument description", "argument type".
+
+LIST OF API BEGINS
+
+{API_LIST}
+
+LIST OF API ENDS
+
+{QUERY}
+
+{chat_history}
+
+{CORRECTION_PROMPT}
+'''
+generation_prompt_template = '''You are an AI Assistant that specializes in Agile Software Development and Product Management and your task is to assist product managers by providing a list of APIs that can solve the given task using only the APIs given below.
+
+Below is a list of APIs with their descriptions. Each API has a name, description and a set of arguments. Each argument has a name, description and type.
+
+LIST OF API BEGINS
+
+{API_LIST}
+
+LIST OF API ENDS
+
+Keep in mind that:
+1. A task might require multiple APIs to be called.
+2. The output can use an API more than one time.
+3. There can be multiple APIs that are used.
+4. Each API can have multiple arguments being used.
+5. To reference the value of the ith API in the list, use $$PREV[i] as argument value. i = 0, 1,  ..  j-1;  j = current API’s index in the list.
+
+A few examples of a query are:
+
+{FEW_SHOT}
+
+{MODIFIED_ARG}
+
+{{QUERY: , REASONING: }}
+  '''

requirements.txt

@@ -0,0 +1,11 @@
+streamlit
+openai<1.0.0
+langchain
+huggingface_hub
+tiktoken
+cohere
+langfuse
+chromadb
+sentence_transformers
+simplejson
+faiss-cpu

retrieval.py

@@ -0,0 +1,46 @@
+from imports import *
+
+loader = CSVLoader(file_path=r'Seed_Dataset.csv')
+data = loader.load()
+
+embeddings = HuggingFaceEmbeddings()
+# persist_directory = 'docs/chroma_db/'
+# !rm -rf ./docs/chroma_db
+vector_db = FAISS.from_documents(
+    documents=data,
+    embedding=embeddings,
+    # persist_directory=persist_directory
+)
+# vector_db.persist()
+
+def store_to_df(store):
+  v_dict = store.docstore._dict
+  data_rows = []
+  for k in v_dict.keys():
+    content = v_dict[k].page_content
+    data_rows.append({"chunk_id" : k, "content" : content})
+  vector_df = pd.DataFrame(data_rows)
+  return vector_df
+
+def show_vstore(store):
+  vector_df = store_to_df(store)
+  # display(vector_df)
+
+def delete_tool_examples(store, tool_name, arg_name = None):
+  vector_df = store_to_df(store)
+  if (arg_name is not None):
+      mask = (vector_df['content'].str.contains(tool_name) & vector_df['content'].str.contains(arg_name))
+  else:
+      mask = vector_df['content'].str.contains(tool_name)
+  chunk_ids_to_delete = vector_df.loc[mask, 'chunk_id']
+  print(chunk_ids_to_delete)
+  try:
+      store.delete(chunk_ids_to_delete)
+  except:
+      print("Unable to delete")
+
+def add_to_vector_store(store, examples):
+  for example in examples:
+    doc = Document(page_content = example)
+    extension = FAISS.from_documents([doc], embeddings)
+    store.merge_from(extension)

update_api_toolset.py

@@ -0,0 +1,169 @@
+from imports import *
+from retrieval import *
+from prompt_templates import *
+from hal_check import *
+
+def API_CHOICE(n, tool_name, api_list):
+  l = []
+  apis = api_list.copy()
+  if tool_name in apis:
+    apis.remove(tool_name)
+  for i in range(n):
+    choice = random.choice(apis)
+    apis.remove(choice)
+    l.append(choice)
+  return l
+
+def generate_examples(tool_name, api_list, store, num_examples = 2, arg_name = None):
+  APIs = API_CHOICE(2, tool_name, api_list)
+  if len(list(store.docstore._dict.values()))>=2:
+    few_shot_examples = random.sample(list(store.docstore._dict.values()), 2)
+    few_shot_examples = [few_shot_examples[0].page_content, few_shot_examples[1].page_content]
+  elif len(list(store.docstore._dict.values()))==1:
+
+    few_shot_examples = random.sample(list(store.docstore._dict.values()), 1)
+    few_shot_examples = [few_shot_examples[0].page_content]
+  else:
+    few_shot_examples=[]
+    
+  examples = []
+  if arg_name is not None:
+    MODIFIED_ARG = f'Now you must only use {APIs} and {tool_name} to generate a query, its reasoning and the finar answer. You, also must use the argument {arg_name} for the tool {tool_name} to generate the query. Now generate a query and give your output in the form of the following dictionary.'
+  else:
+    MODIFIED_ARG = f'Now you must only use {APIs} and {tool_name} to generate a query, its reasoning and the finar answer. Now generate a query and give your output in the form of the following dictionary.'
+  for i in range(num_examples):
+    examples.append(generation_chain.run(API_LIST = api_list, FEW_SHOT = few_shot_examples, MODIFIED_ARG = MODIFIED_ARG))
+  return examples
+
+api_weights = {'works_list': 0,  'prioritize_objects' : 0, 'add_work_items_to_sprint' : 0, 'get_sprint_id' : 0, 'get_similar_work_items' : 0, 'search_object_by_name' : 0,
+               'create_actionable_tasks_from_text' : 0, 'who_am_i' : 0,  'get_works_id' : 0, }
+
+api_list = list(api_weights.keys())
+
+# Function to add a new tool
+def add_tool(api_list, name, description, available_tools, available_arguments, store):
+    available_tools.append(name)
+    api_list.append({"name": name, "description": description, "arguments": []})
+    available_arguments.append(f"{name}/")
+    example = generate_examples(name, api_list, store)
+    add_to_vector_store(store, example)
+    return api_list, available_tools, available_arguments
+
+def delete_tool(api_list, tool_name, available_tools, available_arguments, arg_allowed_values_dict, args_in_list_dict, store):
+    delete_tool_examples(store, tool_name)
+    available_tools.remove(tool_name)
+    available_arguments = [s for s in available_arguments if not s.startswith(tool_name)]
+    arg_allowed_values_dict = {key: value for key, value in arg_allowed_values_dict.items() if not key.startswith(tool_name)}
+    args_in_list_dict = {key: value for key, value in args_in_list_dict.items() if not key.startswith(tool_name)}
+    api_list = [tool for tool in api_list if tool['name'] != tool_name]
+    return api_list, available_tools, available_arguments, arg_allowed_values_dict, args_in_list_dict, store
+
+# Function to update a tool
+def update_tool(api_list, old_tool_name, new_tool_name, new_description, available_tools, available_arguments, arg_allowed_values_dict, args_in_list_dict, store):
+    delete_tool_examples(store, old_tool_name)
+    for tool in api_list:
+        if tool['name'] == old_tool_name:
+            tool['name'] = new_tool_name
+            tool['description'] = new_description
+            break
+    example = generate_examples(new_tool_name, api_list, store, num_examples = 4)
+    add_to_vector_store(store, example)
+    available_tools.remove(old_tool_name)
+    available_tools.append(new_tool_name)
+    available_arguments = [s.replace(old_tool_name, new_tool_name, 1) if s.startswith(old_tool_name) else s for s in available_arguments]
+    keys_to_replace1 = [key for key in arg_allowed_values_dict if key.startswith(old_tool_name)]
+    for key in keys_to_replace1:
+      new_key = key.replace(old_tool_name, new_tool_name)
+      arg_allowed_values_dict[new_key] = arg_allowed_values_dict[key]
+      del arg_allowed_values_dict[key]
+    keys_to_replace2 = [key for key in args_in_list_dict if key.startswith(old_tool_name)]
+    for key in keys_to_replace2:
+      new_key = key.replace(old_tool_name, new_tool_name)
+      args_in_list_dict[new_key] = args_in_list_dict[key]
+      del args_in_list_dict[key]
+    return api_list, available_tools, available_arguments, arg_allowed_values_dict, args_in_list_dict
+
+# Function to add an argument to a tool
+def add_argument(api_list, tool_name, arg_name, arg_desc, arg_type, arg_allowed_values, available_arguments, arg_allowed_values_dict, args_in_list_dict, store):
+    delete_tool_examples(store, tool_name)
+    for tool in api_list:
+      if tool['name'] == tool_name:
+        tool['arguments'].append({
+                "argument_name": arg_name,
+                "argument_description": arg_desc,
+                "argument_type": arg_type
+            })
+        break
+    if 'array' in arg_type.lower() :
+      args_in_list_dict[f'{tool_name}/{arg_name}'] = 1
+    else:
+      args_in_list_dict[f'{tool_name}/{arg_name}'] = 0
+    example = generate_examples(tool_name, api_list, store, num_examples = 4)
+    add_to_vector_store(store, example)
+    available_arguments.append(f"{tool_name}/{arg_name}")
+    if len(arg_allowed_values) is not 0:
+      arg_allowed_values_dict[f'{tool_name}/{arg_name}'] = ast.literal_eval(arg_allowed_values)
+    return api_list, available_arguments, arg_allowed_values_dict, args_in_list_dict
+
+# Function to delete an argument from a tool
+def delete_argument(api_list, tool_name, arg_name, available_arguments, arg_allowed_values_dict, args_in_list_dict, store):
+    delete_tool_examples(store, tool_name, arg_name)
+    for tool in api_list:
+        if tool['name'] == tool_name:
+            tool['arguments'] = [arg for arg in tool['arguments'] if arg['argument_name'] != arg_name]
+            break
+    examples = generate_examples(tool_name, api_list, store)
+    add_to_vector_store(store, examples)
+    arg_to_delete = f"{tool_name}/{arg_name}"
+    available_arguments.remove(arg_to_delete)
+    if arg_to_delete in arg_allowed_values_dict:
+      del arg_allowed_values_dict[arg_to_delete]
+    if arg_to_delete in args_in_list_dict:
+      del args_in_list_dict[arg_to_delete]
+    return api_list, available_arguments, arg_allowed_values_dict, args_in_list_dict
+
+# Function to update an argument
+def update_argument(api_list, tool_name, old_arg_name, new_arg_name, new_arg_desc, new_arg_type, new_arg_allowed_values, available_arguments, arg_allowed_values_dict, args_in_list_dict, store):
+    delete_tool_examples(store, tool_name, old_arg_name)
+    for tool in api_list:
+        if tool['name'] == tool_name:
+            for arg in tool['arguments']:
+                if arg['argument_name'] == old_arg_name:
+                    arg['argument_name'] = new_arg_name
+                    arg['argument_description'] = new_arg_desc
+                    arg['argument_type'] = new_arg_type
+                    break
+            break
+    examples = generate_examples(tool_name, api_list, store, arg_name = new_arg_name)
+    add_to_vector_store(store, examples)
+    available_arguments.remove(f"{tool_name}/{old_arg_name}")
+    available_arguments.append(f"{tool_name}/{new_arg_name}")
+    if f"{tool_name}/{old_arg_name}" in arg_allowed_values_dict:
+      del arg_allowed_values_dict[f"{tool_name}/{old_arg_name}"]
+    if f"{tool_name}/{old_arg_name}" in args_in_list_dict:
+      del args_in_list_dict[f"{tool_name}/{old_arg_name}"]
+    if len(new_arg_allowed_values) is not 0:
+      arg_allowed_values_dict[f'{tool_name}/{new_arg_name}'] = ast.literal_eval(new_arg_allowed_values)
+    if 'array' in new_arg_type.lower() :
+      args_in_list_dict[f'{tool_name}/{new_arg_name}'] = 1
+    else:
+      args_in_list_dict[f'{tool_name}/{new_arg_name}'] = 0
+    return api_list, available_arguments, arg_allowed_values_dict, args_in_list_dict
+
+# Function to delete multiple arguments from a tool
+def delete_multiple_arguments(api_list, tool_name, arg_names, available_arguments, arg_allowed_values_dict, args_in_list_dict, store):
+  for arg_name in arg_names :
+      delete_tool_examples(store, tool_name, arg_name)
+      arg_to_delete = f"{tool_name}/{arg_name}"
+      available_arguments.remove(arg_to_delete)
+      if arg_to_delete in arg_allowed_values_dict:
+        del arg_allowed_values_dict[arg_to_delete]
+      if arg_to_delete in args_in_list_dict:
+        del args_in_list_dict[arg_to_delete]
+  for tool in api_list:
+      if tool['name'] == tool_name:
+          tool['arguments'] = [arg for arg in tool['arguments'] if arg['argument_name'] not in arg_names]
+          break
+  examples = generate_examples(tool_name, api_list, store)
+  add_to_vector_store(store, examples)
+  return api_list, available_arguments, arg_allowed_values_dict, args_in_list_dict