From 2d6b3b06060110e3b38459cb4292ea37687eb627 Mon Sep 17 00:00:00 2001
From: Pravesh Kumar <121786590+praveshkumar1988@users.noreply.github.com>
Date: Tue, 25 Mar 2025 11:53:20 +0000
Subject: [PATCH 1/8] Added new API user_details and implement functionality
 for neo4j user has no limit on tokens

---
 backend/score.py                  | 38 +++++++++++++++++++++-----
 backend/src/create_chunks.py      |  4 +--
 backend/src/graphDB_dataAccess.py |  8 +++++-
 backend/src/main.py               | 44 +++++++++++++++----------------
 4 files changed, 62 insertions(+), 32 deletions(-)

diff --git a/backend/score.py b/backend/score.py
index 75181e096..6e43f5f34 100644
--- a/backend/score.py
+++ b/backend/score.py
@@ -218,7 +218,8 @@ async def extract_knowledge_graph_from_file(
     access_token=Form(None),
     retry_condition=Form(None),
     additional_instructions=Form(None),
-    email=Form(None)
+    email=Form(None),
+    is_neo4j_user=Form(False)
 ):
     """
     Calls 'extract_graph_from_file' in a new thread to create Neo4jGraph from a
@@ -241,22 +242,22 @@ async def extract_knowledge_graph_from_file(
         if source_type == 'local file':
             file_name = sanitize_filename(file_name)
             merged_file_path = validate_file_path(MERGED_DIR, file_name)
-            uri_latency, result = await extract_graph_from_file_local_file(uri, userName, password, database, model, merged_file_path, file_name, allowedNodes, allowedRelationship, token_chunk_size, chunk_overlap, chunks_to_combine, retry_condition, additional_instructions)
+            uri_latency, result = await extract_graph_from_file_local_file(uri, userName, password, database, model, merged_file_path, file_name, allowedNodes, allowedRelationship, token_chunk_size, chunk_overlap, chunks_to_combine, retry_condition, additional_instructions, is_neo4j_user)
 
         elif source_type == 's3 bucket' and source_url:
-            uri_latency, result = await extract_graph_from_file_s3(uri, userName, password, database, model, source_url, aws_access_key_id, aws_secret_access_key, file_name, allowedNodes, allowedRelationship, token_chunk_size, chunk_overlap, chunks_to_combine, retry_condition, additional_instructions)
+            uri_latency, result = await extract_graph_from_file_s3(uri, userName, password, database, model, source_url, aws_access_key_id, aws_secret_access_key, file_name, allowedNodes, allowedRelationship, token_chunk_size, chunk_overlap, chunks_to_combine, retry_condition, additional_instructions, is_neo4j_user)
         
         elif source_type == 'web-url':
-            uri_latency, result = await extract_graph_from_web_page(uri, userName, password, database, model, source_url, file_name, allowedNodes, allowedRelationship, token_chunk_size, chunk_overlap, chunks_to_combine, retry_condition, additional_instructions)
+            uri_latency, result = await extract_graph_from_web_page(uri, userName, password, database, model, source_url, file_name, allowedNodes, allowedRelationship, token_chunk_size, chunk_overlap, chunks_to_combine, retry_condition, additional_instructions, is_neo4j_user)
 
         elif source_type == 'youtube' and source_url:
-            uri_latency, result = await extract_graph_from_file_youtube(uri, userName, password, database, model, source_url, file_name, allowedNodes, allowedRelationship, token_chunk_size, chunk_overlap, chunks_to_combine, retry_condition, additional_instructions)
+            uri_latency, result = await extract_graph_from_file_youtube(uri, userName, password, database, model, source_url, file_name, allowedNodes, allowedRelationship, token_chunk_size, chunk_overlap, chunks_to_combine, retry_condition, additional_instructions, is_neo4j_user)
 
         elif source_type == 'Wikipedia' and wiki_query:
-            uri_latency, result = await extract_graph_from_file_Wikipedia(uri, userName, password, database, model, wiki_query, language, file_name, allowedNodes, allowedRelationship, token_chunk_size, chunk_overlap, chunks_to_combine, retry_condition, additional_instructions)
+            uri_latency, result = await extract_graph_from_file_Wikipedia(uri, userName, password, database, model, wiki_query, language, file_name, allowedNodes, allowedRelationship, token_chunk_size, chunk_overlap, chunks_to_combine, retry_condition, additional_instructions, is_neo4j_user)
 
         elif source_type == 'gcs bucket' and gcs_bucket_name:
-            uri_latency, result = await extract_graph_from_file_gcs(uri, userName, password, database, model, gcs_project_id, gcs_bucket_name, gcs_bucket_folder, gcs_blob_filename, access_token, file_name, allowedNodes, allowedRelationship, token_chunk_size, chunk_overlap, chunks_to_combine, retry_condition, additional_instructions)
+            uri_latency, result = await extract_graph_from_file_gcs(uri, userName, password, database, model, gcs_project_id, gcs_bucket_name, gcs_bucket_folder, gcs_blob_filename, access_token, file_name, allowedNodes, allowedRelationship, token_chunk_size, chunk_overlap, chunks_to_combine, retry_condition, additional_instructions, is_neo4j_user)
         else:
             return create_api_response('Failed',message='source_type is other than accepted source')
         extract_api_time = time.time() - start_time
@@ -1096,5 +1097,28 @@ async def get_schema_visualization(uri=Form(None), userName=Form(None), password
     finally:
         gc.collect()
 
+@app.post("/user_details")
+async def user_details(uri=Form(None), 
+                    userName=Form(None), 
+                    password=Form(None), 
+                    database=Form(None), 
+                    email=Form(None)):
+    try:
+        start = time.time()
+        graph = create_graph_database_connection(uri, userName, password, database)
+        graphDb_data_Access = graphDBdataAccess(graph)
+        result = graphDb_data_Access.save_user_details(email)
+        end = time.time()
+        elapsed_time = end - start
+        return create_api_response('Success', data=result,message=f"Total elapsed API time {elapsed_time:.2f}")
+    except Exception as e:
+        message="Unable to get schema visualization from neo4j database"
+        error_message = str(e)
+        logging.info(message)
+        logging.exception(f'Exception:{error_message}')
+        return create_api_response("Failed", message=message, error=error_message)
+    finally:
+        gc.collect()
+
 if __name__ == "__main__":
     uvicorn.run(app)
\ No newline at end of file
diff --git a/backend/src/create_chunks.py b/backend/src/create_chunks.py
index 523d2b77c..4657701cd 100644
--- a/backend/src/create_chunks.py
+++ b/backend/src/create_chunks.py
@@ -14,7 +14,7 @@ def __init__(self, pages: list[Document], graph: Neo4jGraph):
         self.pages = pages
         self.graph = graph
 
-    def split_file_into_chunks(self,token_chunk_size, chunk_overlap):
+    def split_file_into_chunks(self,token_chunk_size, chunk_overlap, is_neo4j_user):
         """
         Split a list of documents(file pages) into chunks of fixed size.
 
@@ -33,7 +33,7 @@ def split_file_into_chunks(self,token_chunk_size, chunk_overlap):
             chunks = []
             for i, document in enumerate(self.pages):
                 page_number = i + 1
-                if len(chunks) >= chunk_to_be_created:
+                if not is_neo4j_user and len(chunks) >= chunk_to_be_created:
                     break
                 else:
                     for chunk in text_splitter.split_documents([document]):
diff --git a/backend/src/graphDB_dataAccess.py b/backend/src/graphDB_dataAccess.py
index 397227a9a..5a729fb59 100644
--- a/backend/src/graphDB_dataAccess.py
+++ b/backend/src/graphDB_dataAccess.py
@@ -583,4 +583,10 @@ def get_websource_url(self,file_name):
                 RETURN d.url AS url
                 """
         param = {"file_name" : file_name}
-        return self.execute_query(query, param)
\ No newline at end of file
+        return self.execute_query(query, param)
+    
+    def save_user_details(self,email, database):
+        domain = "@neo4j.com"
+        is_neo4j_user = domain in email
+        write_access = self.check_account_access(database=database)
+        return {"is_neo4j_user": is_neo4j_user, "write_access": write_access}
\ No newline at end of file
diff --git a/backend/src/main.py b/backend/src/main.py
index 41e69e6f4..d3859f24d 100644
--- a/backend/src/main.py
+++ b/backend/src/main.py
@@ -226,7 +226,7 @@ def create_source_node_graph_url_wikipedia(graph, model, wiki_query, source_type
       lst_file_name.append({'fileName':obj_source_node.file_name,'fileSize':obj_source_node.file_size,'url':obj_source_node.url, 'language':obj_source_node.language, 'status':'Success'})
     return lst_file_name,success_count,failed_count
     
-async def extract_graph_from_file_local_file(uri, userName, password, database, model, merged_file_path, fileName, allowedNodes, allowedRelationship, token_chunk_size, chunk_overlap, chunks_to_combine, retry_condition, additional_instructions):
+async def extract_graph_from_file_local_file(uri, userName, password, database, model, merged_file_path, fileName, allowedNodes, allowedRelationship, token_chunk_size, chunk_overlap, chunks_to_combine, retry_condition, additional_instructions, is_neo4j_user):
 
   logging.info(f'Process file name :{fileName}')
   if not retry_condition:
@@ -238,11 +238,11 @@ async def extract_graph_from_file_local_file(uri, userName, password, database,
       file_name, pages, file_extension = get_documents_from_file_by_path(merged_file_path,fileName)
     if pages==None or len(pages)==0:
       raise LLMGraphBuilderException(f'File content is not available for file : {file_name}')
-    return await processing_source(uri, userName, password, database, model, file_name, pages, allowedNodes, allowedRelationship, token_chunk_size, chunk_overlap, chunks_to_combine, True, merged_file_path, additional_instructions=additional_instructions)
+    return await processing_source(uri, userName, password, database, model, file_name, pages, allowedNodes, allowedRelationship, token_chunk_size, chunk_overlap, chunks_to_combine, additional_instructions, is_neo4j_user, is_uploaded_from_local= True, merged_file_path= merged_file_path)
   else:
-    return await processing_source(uri, userName, password, database, model, fileName, [], allowedNodes, allowedRelationship, token_chunk_size, chunk_overlap, chunks_to_combine, True, merged_file_path, retry_condition, additional_instructions=additional_instructions)
+    return await processing_source(uri, userName, password, database, model, fileName, [], allowedNodes, allowedRelationship, token_chunk_size, chunk_overlap, chunks_to_combine, additional_instructions, is_neo4j_user, retry_condition, True, merged_file_path)
   
-async def extract_graph_from_file_s3(uri, userName, password, database, model, source_url, aws_access_key_id, aws_secret_access_key, file_name, allowedNodes, allowedRelationship, token_chunk_size, chunk_overlap, chunks_to_combine, retry_condition, additional_instructions):
+async def extract_graph_from_file_s3(uri, userName, password, database, model, source_url, aws_access_key_id, aws_secret_access_key, file_name, allowedNodes, allowedRelationship, token_chunk_size, chunk_overlap, chunks_to_combine, retry_condition, additional_instructions, is_neo4j_user):
   if not retry_condition:
     if(aws_access_key_id==None or aws_secret_access_key==None):
       raise LLMGraphBuilderException('Please provide AWS access and secret keys')
@@ -252,48 +252,48 @@ async def extract_graph_from_file_s3(uri, userName, password, database, model, s
 
     if pages==None or len(pages)==0:
       raise LLMGraphBuilderException(f'File content is not available for file : {file_name}')
-    return await processing_source(uri, userName, password, database, model, file_name, pages, allowedNodes, allowedRelationship, token_chunk_size, chunk_overlap, chunks_to_combine, additional_instructions=additional_instructions)
+    return await processing_source(uri, userName, password, database, model, file_name, pages, allowedNodes, allowedRelationship, token_chunk_size, chunk_overlap, chunks_to_combine, additional_instructions, is_neo4j_user)
   else:
-    return await processing_source(uri, userName, password, database, model, file_name, [], allowedNodes, allowedRelationship, token_chunk_size, chunk_overlap, chunks_to_combine, retry_condition=retry_condition, additional_instructions=additional_instructions)
+    return await processing_source(uri, userName, password, database, model, file_name, [], allowedNodes, allowedRelationship, token_chunk_size, chunk_overlap, chunks_to_combine, additional_instructions, is_neo4j_user, retry_condition)
   
-async def extract_graph_from_web_page(uri, userName, password, database, model, source_url, file_name, allowedNodes, allowedRelationship, token_chunk_size, chunk_overlap, chunks_to_combine, retry_condition, additional_instructions):
+async def extract_graph_from_web_page(uri, userName, password, database, model, source_url, file_name, allowedNodes, allowedRelationship, token_chunk_size, chunk_overlap, chunks_to_combine, retry_condition, additional_instructions, is_neo4j_user):
   if not retry_condition:
     pages = get_documents_from_web_page(source_url)
     if pages==None or len(pages)==0:
       raise LLMGraphBuilderException(f'Content is not available for given URL : {file_name}')
-    return await processing_source(uri, userName, password, database, model, file_name, pages, allowedNodes, allowedRelationship, token_chunk_size, chunk_overlap, chunks_to_combine, additional_instructions=additional_instructions)
+    return await processing_source(uri, userName, password, database, model, file_name, pages, allowedNodes, allowedRelationship, token_chunk_size, chunk_overlap, chunks_to_combine, additional_instructions, is_neo4j_user)
   else:
-    return await processing_source(uri, userName, password, database, model, file_name, [], allowedNodes, allowedRelationship, token_chunk_size, chunk_overlap, chunks_to_combine, retry_condition=retry_condition, additional_instructions=additional_instructions)
+    return await processing_source(uri, userName, password, database, model, file_name, [], allowedNodes, allowedRelationship, token_chunk_size, chunk_overlap, chunks_to_combine, additional_instructions, is_neo4j_user, retry_condition)
   
-async def extract_graph_from_file_youtube(uri, userName, password, database, model, source_url, file_name, allowedNodes, allowedRelationship, token_chunk_size, chunk_overlap, chunks_to_combine, retry_condition, additional_instructions):
+async def extract_graph_from_file_youtube(uri, userName, password, database, model, source_url, file_name, allowedNodes, allowedRelationship, token_chunk_size, chunk_overlap, chunks_to_combine, retry_condition, additional_instructions, is_neo4j_user):
   if not retry_condition:
     file_name, pages = get_documents_from_youtube(source_url)
 
     if pages==None or len(pages)==0:
       raise LLMGraphBuilderException(f'Youtube transcript is not available for file : {file_name}')
-    return await processing_source(uri, userName, password, database, model, file_name, pages, allowedNodes, allowedRelationship, token_chunk_size, chunk_overlap, chunks_to_combine, additional_instructions=additional_instructions)
+    return await processing_source(uri, userName, password, database, model, file_name, pages, allowedNodes, allowedRelationship, token_chunk_size, chunk_overlap, chunks_to_combine, additional_instructions, is_neo4j_user)
   else:
-     return await processing_source(uri, userName, password, database, model, file_name, [], allowedNodes, allowedRelationship, token_chunk_size, chunk_overlap, chunks_to_combine, retry_condition=retry_condition, additional_instructions=additional_instructions)
+     return await processing_source(uri, userName, password, database, model, file_name, [], allowedNodes, allowedRelationship, token_chunk_size, chunk_overlap, chunks_to_combine, additional_instructions, is_neo4j_user, retry_condition)
     
-async def extract_graph_from_file_Wikipedia(uri, userName, password, database, model, wiki_query, language, file_name, allowedNodes, allowedRelationship, token_chunk_size, chunk_overlap, chunks_to_combine, retry_condition, additional_instructions):
+async def extract_graph_from_file_Wikipedia(uri, userName, password, database, model, wiki_query, language, file_name, allowedNodes, allowedRelationship, token_chunk_size, chunk_overlap, chunks_to_combine, retry_condition, additional_instructions, is_neo4j_user):
   if not retry_condition:
     file_name, pages = get_documents_from_Wikipedia(wiki_query, language)
     if pages==None or len(pages)==0:
       raise LLMGraphBuilderException(f'Wikipedia page is not available for file : {file_name}')
-    return await processing_source(uri, userName, password, database, model, file_name, pages, allowedNodes, allowedRelationship, token_chunk_size, chunk_overlap, chunks_to_combine, additional_instructions=additional_instructions)
+    return await processing_source(uri, userName, password, database, model, file_name, pages, allowedNodes, allowedRelationship, token_chunk_size, chunk_overlap, chunks_to_combine, additional_instructions, is_neo4j_user)
   else:
-    return await processing_source(uri, userName, password, database, model, file_name,[], allowedNodes, allowedRelationship, token_chunk_size, chunk_overlap, chunks_to_combine, retry_condition=retry_condition, additional_instructions=additional_instructions)
+    return await processing_source(uri, userName, password, database, model, file_name,[], allowedNodes, allowedRelationship, token_chunk_size, chunk_overlap, chunks_to_combine, additional_instructions, is_neo4j_user, retry_condition)
 
-async def extract_graph_from_file_gcs(uri, userName, password, database, model, gcs_project_id, gcs_bucket_name, gcs_bucket_folder, gcs_blob_filename, access_token, file_name, allowedNodes, allowedRelationship, token_chunk_size, chunk_overlap, chunks_to_combine, retry_condition, additional_instructions):
+async def extract_graph_from_file_gcs(uri, userName, password, database, model, gcs_project_id, gcs_bucket_name, gcs_bucket_folder, gcs_blob_filename, access_token, file_name, allowedNodes, allowedRelationship, token_chunk_size, chunk_overlap, chunks_to_combine, retry_condition, additional_instructions, is_neo4j_user):
   if not retry_condition:
     file_name, pages = get_documents_from_gcs(gcs_project_id, gcs_bucket_name, gcs_bucket_folder, gcs_blob_filename, access_token)
     if pages==None or len(pages)==0:
       raise LLMGraphBuilderException(f'File content is not available for file : {file_name}')
-    return await processing_source(uri, userName, password, database, model, file_name, pages, allowedNodes, allowedRelationship, token_chunk_size, chunk_overlap, chunks_to_combine, additional_instructions=additional_instructions)
+    return await processing_source(uri, userName, password, database, model, file_name, pages, allowedNodes, allowedRelationship, token_chunk_size, chunk_overlap, chunks_to_combine, additional_instructions, is_neo4j_user)
   else:
-    return await processing_source(uri, userName, password, database, model, file_name, [], allowedNodes, allowedRelationship, token_chunk_size, chunk_overlap, chunks_to_combine, retry_condition=retry_condition, additional_instructions=additional_instructions)
+    return await processing_source(uri, userName, password, database, model, file_name, [], allowedNodes, allowedRelationship, token_chunk_size, chunk_overlap, chunks_to_combine, additional_instructions, is_neo4j_user, retry_condition)
   
-async def processing_source(uri, userName, password, database, model, file_name, pages, allowedNodes, allowedRelationship, token_chunk_size, chunk_overlap, chunks_to_combine, is_uploaded_from_local=None, merged_file_path=None, retry_condition=None, additional_instructions=None):
+async def processing_source(uri, userName, password, database, model, file_name, pages, allowedNodes, allowedRelationship, token_chunk_size, chunk_overlap, chunks_to_combine, additional_instructions, is_neo4j_user, retry_condition = None, is_uploaded_from_local=False, merged_file_path=None):
   """
    Extracts a Neo4jGraph from a PDF file based on the model.
    
@@ -322,7 +322,7 @@ async def processing_source(uri, userName, password, database, model, file_name,
   graphDb_data_Access = graphDBdataAccess(graph)
   create_chunk_vector_index(graph)
   start_get_chunkId_chunkDoc_list = time.time()
-  total_chunks, chunkId_chunkDoc_list = get_chunkId_chunkDoc_list(graph, file_name, pages, token_chunk_size, chunk_overlap, retry_condition)
+  total_chunks, chunkId_chunkDoc_list = get_chunkId_chunkDoc_list(graph, file_name, pages, token_chunk_size, chunk_overlap, retry_condition, is_neo4j_user)
   end_get_chunkId_chunkDoc_list = time.time()
   elapsed_get_chunkId_chunkDoc_list = end_get_chunkId_chunkDoc_list - start_get_chunkId_chunkDoc_list
   logging.info(f'Time taken to create list chunkids with chunk document: {elapsed_get_chunkId_chunkDoc_list:.2f} seconds')
@@ -509,7 +509,7 @@ async def processing_chunks(chunkId_chunkDoc_list,graph,uri, userName, password,
   rel_count = count_response[file_name].get('relationshipCount',"0")
   return node_count,rel_count,latency_processing_chunk
 
-def get_chunkId_chunkDoc_list(graph, file_name, pages, token_chunk_size, chunk_overlap, retry_condition):
+def get_chunkId_chunkDoc_list(graph, file_name, pages, token_chunk_size, chunk_overlap, retry_condition, is_neo4j_user):
   if not retry_condition:
     logging.info("Break down file into chunks")
     bad_chars = ['"', "\n", "'"]
@@ -522,7 +522,7 @@ def get_chunkId_chunkDoc_list(graph, file_name, pages, token_chunk_size, chunk_o
           text = text.replace(j, '')
       pages[i]=Document(page_content=str(text), metadata=pages[i].metadata)
     create_chunks_obj = CreateChunksofDocument(pages, graph)
-    chunks = create_chunks_obj.split_file_into_chunks(token_chunk_size, chunk_overlap)
+    chunks = create_chunks_obj.split_file_into_chunks(token_chunk_size, chunk_overlap, is_neo4j_user)
     chunkId_chunkDoc_list = create_relation_between_chunks(graph,file_name,chunks)
     return len(chunks), chunkId_chunkDoc_list
   

From 5fd9d6904a8abe3eecfed0b4a107a252e10f6cf2 Mon Sep 17 00:00:00 2001
From: Pravesh Kumar <121786590+praveshkumar1988@users.noreply.github.com>
Date: Tue, 25 Mar 2025 11:56:20 +0000
Subject: [PATCH 2/8] update the message

---
 backend/score.py | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/backend/score.py b/backend/score.py
index 6e43f5f34..508fc67a4 100644
--- a/backend/score.py
+++ b/backend/score.py
@@ -1112,7 +1112,7 @@ async def user_details(uri=Form(None),
         elapsed_time = end - start
         return create_api_response('Success', data=result,message=f"Total elapsed API time {elapsed_time:.2f}")
     except Exception as e:
-        message="Unable to get schema visualization from neo4j database"
+        message="Unable to save the detail of user in DB"
         error_message = str(e)
         logging.info(message)
         logging.exception(f'Exception:{error_message}')

From 8d5b4b91aa89b9351b18286ff0f43027e55de3b9 Mon Sep 17 00:00:00 2001
From: kartikpersistent <101251502+kartikpersistent@users.noreply.github.com>
Date: Tue, 25 Mar 2025 12:55:01 +0000
Subject: [PATCH 3/8] userdetails api integration

---
 frontend/src/components/Content.tsx           | 28 +----------------
 .../components/DataSources/AWS/S3Modal.tsx    |  2 +-
 .../components/DataSources/GCS/GCSModal.tsx   |  2 +-
 frontend/src/components/FileTable.tsx         |  4 +--
 .../AdditionalInstructions/index.tsx          |  8 ++++-
 .../{HOC => components/UI}/CustomModal.tsx    |  4 +--
 frontend/src/components/User/Profile.tsx      | 30 +++++++++++++++----
 frontend/src/context/UserCredentials.tsx      | 11 +++----
 .../{getChunkText.ts => GetChunkTexts.ts}     |  8 ++---
 frontend/src/services/UserDetails.ts          | 16 ++++++++++
 frontend/src/types.ts                         | 15 ++++++++--
 11 files changed, 77 insertions(+), 51 deletions(-)
 rename frontend/src/{HOC => components/UI}/CustomModal.tsx (92%)
 rename frontend/src/services/{getChunkText.ts => GetChunkTexts.ts} (63%)
 create mode 100644 frontend/src/services/UserDetails.ts

diff --git a/frontend/src/components/Content.tsx b/frontend/src/components/Content.tsx
index 4f8904fd9..e9851ec19 100644
--- a/frontend/src/components/Content.tsx
+++ b/frontend/src/components/Content.tsx
@@ -45,7 +45,7 @@ import retry from '../services/Retry';
 import { showErrorToast, showNormalToast, showSuccessToast } from '../utils/Toasts';
 import { useMessageContext } from '../context/UserMessages';
 import PostProcessingToast from './Popups/GraphEnhancementDialog/PostProcessingCheckList/PostProcessingToast';
-import { getChunkText } from '../services/getChunkText';
+import { getChunkText } from '../services/GetChunkTexts';
 import ChunkPopUp from './Popups/ChunkPopUp';
 import { isExpired, isFileReadyToProcess } from '../utils/Utils';
 import { useHasSelections } from '../hooks/useHasSelections';
@@ -836,32 +836,6 @@ const Content: React.FC<ContentProps> = ({
           ></ConfirmationDialog>
         </Suspense>
       )}
-      {showExpirationModal && filesForProcessing.length && (
-        <Suspense fallback={<FallBackDialog />}>
-          <ConfirmationDialog
-            open={showExpirationModal}
-            largeFiles={filesForProcessing}
-            extractHandler={handleGenerateGraph}
-            onClose={() => setShowExpirationModal(false)}
-            loading={extractLoading}
-            selectedRows={childRef.current?.getSelectedRows() as CustomFile[]}
-            isLargeDocumentAlert={false}
-          ></ConfirmationDialog>
-        </Suspense>
-      )}
-      {showExpirationModal && filesForProcessing.length && (
-        <Suspense fallback={<FallBackDialog />}>
-          <ConfirmationDialog
-            open={showExpirationModal}
-            largeFiles={filesForProcessing}
-            extractHandler={handleGenerateGraph}
-            onClose={() => setShowExpirationModal(false)}
-            loading={extractLoading}
-            selectedRows={childRef.current?.getSelectedRows() as CustomFile[]}
-            isLargeDocumentAlert={false}
-          ></ConfirmationDialog>
-        </Suspense>
-      )}
       {showDeletePopUp && (
         <DeletePopUp
           open={showDeletePopUp}
diff --git a/frontend/src/components/DataSources/AWS/S3Modal.tsx b/frontend/src/components/DataSources/AWS/S3Modal.tsx
index 30f07e65b..3579916af 100644
--- a/frontend/src/components/DataSources/AWS/S3Modal.tsx
+++ b/frontend/src/components/DataSources/AWS/S3Modal.tsx
@@ -5,7 +5,7 @@ import { urlScanAPI } from '../../../services/URLScan';
 import { validation } from '../../../utils/Utils';
 import { useFileContext } from '../../../context/UsersFiles';
 import { v4 as uuidv4 } from 'uuid';
-import CustomModal from '../../../HOC/CustomModal';
+import CustomModal from '../../UI/CustomModal';
 import { buttonCaptions } from '../../../utils/Constants';
 
 const S3Modal: React.FC<S3ModalProps> = ({ hideModal, open }) => {
diff --git a/frontend/src/components/DataSources/GCS/GCSModal.tsx b/frontend/src/components/DataSources/GCS/GCSModal.tsx
index f0ee06996..1b3e70928 100644
--- a/frontend/src/components/DataSources/GCS/GCSModal.tsx
+++ b/frontend/src/components/DataSources/GCS/GCSModal.tsx
@@ -4,7 +4,7 @@ import { useFileContext } from '../../../context/UsersFiles';
 import { urlScanAPI } from '../../../services/URLScan';
 import { CustomFileBase, GCSModalProps, fileName, nonoautherror } from '../../../types';
 import { v4 as uuidv4 } from 'uuid';
-import CustomModal from '../../../HOC/CustomModal';
+import CustomModal from '../../UI/CustomModal';
 import { useGoogleLogin } from '@react-oauth/google';
 import { useAlertContext } from '../../../context/Alert';
 import { buttonCaptions } from '../../../utils/Constants';
diff --git a/frontend/src/components/FileTable.tsx b/frontend/src/components/FileTable.tsx
index 1617d88a1..f3b0847a8 100644
--- a/frontend/src/components/FileTable.tsx
+++ b/frontend/src/components/FileTable.tsx
@@ -74,7 +74,7 @@ const FileTable: ForwardRefRenderFunction<ChildRef, FileTableProps> = (props, re
   const { connectionStatus, setConnectionStatus, onInspect, onRetry, onChunkView } = props;
   const { filesData, setFilesData, model, rowSelection, setRowSelection, setSelectedRows, setProcessedCount, queue } =
     useFileContext();
-  const { userCredentials, isReadOnlyUser } = useCredentials();
+  const { userCredentials, isReadOnlyUser, isNeo4jUser } = useCredentials();
   const columnHelper = createColumnHelper<CustomFile>();
   const [columnFilters, setColumnFilters] = useState<ColumnFiltersState>([]);
   const [isLoading, setIsLoading] = useState<boolean>(false);
@@ -1020,7 +1020,7 @@ const FileTable: ForwardRefRenderFunction<ChildRef, FileTableProps> = (props, re
                       </Flex>
                     </DataGridComponents.TableResults>
                   );
-                } else if (connectionStatus) {
+                } else if (connectionStatus && !isNeo4jUser) {
                   return (
                     <DataGridComponents.TableResults>
                       <Flex flexDirection='row' gap='0' alignItems='center'>
diff --git a/frontend/src/components/Popups/GraphEnhancementDialog/AdditionalInstructions/index.tsx b/frontend/src/components/Popups/GraphEnhancementDialog/AdditionalInstructions/index.tsx
index 0cf693138..1f62a05a4 100644
--- a/frontend/src/components/Popups/GraphEnhancementDialog/AdditionalInstructions/index.tsx
+++ b/frontend/src/components/Popups/GraphEnhancementDialog/AdditionalInstructions/index.tsx
@@ -14,6 +14,7 @@ import { useFileContext } from '../../../../context/UsersFiles';
 import { showNormalToast } from '../../../../utils/Toasts';
 import { OnChangeValue } from 'react-select';
 import { OptionType } from '../../../../types';
+import { useCredentials } from '../../../../context/UserCredentials';
 
 export default function AdditionalInstructionsText({
   closeEnhanceGraphSchemaDialog,
@@ -22,6 +23,7 @@ export default function AdditionalInstructionsText({
 }) {
   const { breakpoints } = tokens;
   const tablet = useMediaQuery(`(min-width:${breakpoints.xs}) and (max-width: ${breakpoints.lg})`);
+  const { isNeo4jUser } = useCredentials();
   const {
     additionalInstructions,
     setAdditionalInstructions,
@@ -134,7 +136,11 @@ export default function AdditionalInstructionsText({
                 `,
           }}
           type='creatable'
-          helpText='The maximum token limit is 10,000 for LLM processing. The total number of chunks will be calculated as 10,000 divided by the tokens per chunk you select. For example, selecting 500 tokens per chunk results in 20 chunks (10,000 / 500).'
+          helpText={
+            !isNeo4jUser
+              ? 'The maximum token limit is 10,000 for LLM processing. The total number of chunks will be calculated as 10,000 divided by the tokens per chunk you select. For example, selecting 500 tokens per chunk results in 20 chunks (10,000 / 500).'
+              : null
+          }
         />
         <Select
           label='Chunk Overlap'
diff --git a/frontend/src/HOC/CustomModal.tsx b/frontend/src/components/UI/CustomModal.tsx
similarity index 92%
rename from frontend/src/HOC/CustomModal.tsx
rename to frontend/src/components/UI/CustomModal.tsx
index 814a4343c..e52858cd7 100644
--- a/frontend/src/HOC/CustomModal.tsx
+++ b/frontend/src/components/UI/CustomModal.tsx
@@ -1,6 +1,6 @@
 import { Banner, Button, Dialog } from '@neo4j-ndl/react';
-import { CustomModalProps } from '../types';
-import { buttonCaptions } from '../utils/Constants';
+import { CustomModalProps } from '../../types';
+import { buttonCaptions } from '../../utils/Constants';
 
 const CustomModal: React.FC<CustomModalProps> = ({
   open,
diff --git a/frontend/src/components/User/Profile.tsx b/frontend/src/components/User/Profile.tsx
index 6c31c9f96..65d42cf6b 100644
--- a/frontend/src/components/User/Profile.tsx
+++ b/frontend/src/components/User/Profile.tsx
@@ -1,11 +1,14 @@
-import { useMemo, useRef, useState } from 'react';
+import { useMemo, useRef, useState, useEffect, useCallback } from 'react';
 import { Menu, Typography, IconButton, Avatar } from '@neo4j-ndl/react';
 import { ChevronDownIconOutline } from '@neo4j-ndl/react/icons';
 import { useAuth0 } from '@auth0/auth0-react';
+import userDetails from '../../services/UserDetails';
+import { useCredentials } from '../../context/UserCredentials';
 
 export default function Profile() {
   const [showMenu, setShowOpen] = useState<boolean>(false);
   const iconbtnRef = useRef<HTMLButtonElement | null>(null);
+  const { setNeo4jUser, setIsReadOnlyUser, userCredentials } = useCredentials();
   const { user, isAuthenticated, isLoading, logout } = useAuth0();
   const settings = useMemo(
     () => [
@@ -19,12 +22,29 @@ export default function Profile() {
     []
   );
 
-  const handleClick = () => {
+  useEffect(() => {
+    if (!isLoading && isAuthenticated && userCredentials !== null) {
+      (async () => {
+        try {
+          const userdetails = await userDetails();
+          if (userdetails.status === 'Failed') {
+            throw new Error(userdetails.error);
+          }
+          setNeo4jUser(userdetails.data.is_neo4j_user);
+          setIsReadOnlyUser(!userdetails.data.write_access);
+        } catch (error) {
+          console.log(`error in userDetails api, ${error}`);
+        }
+      })();
+    }
+  }, [isLoading, isAuthenticated, userCredentials]);
+  const handleClick = useCallback(() => {
     setShowOpen(true);
-  };
-  const handleClose = () => {
+  }, []);
+  const handleClose = useCallback(() => {
     setShowOpen(false);
-  };
+  }, []);
+
   if (isLoading) {
     return <Avatar></Avatar>;
   }
diff --git a/frontend/src/context/UserCredentials.tsx b/frontend/src/context/UserCredentials.tsx
index 83718bc51..a0292cb37 100644
--- a/frontend/src/context/UserCredentials.tsx
+++ b/frontend/src/context/UserCredentials.tsx
@@ -23,8 +23,8 @@ export const UserConnection = createContext<ContextProps>({
   setShowDisconnectButton: () => null,
   isGCSActive: false,
   setIsGCSActive: () => null,
-  //  chunksToBeProces: 50,
-  // setChunksToBeProces: () => null,
+  isNeo4jUser: false,
+  setNeo4jUser: () => null,
 });
 export const useCredentials = () => {
   const userCredentials = useContext(UserConnection);
@@ -39,7 +39,8 @@ const UserCredentialsWrapper: FunctionComponent<Props> = (props) => {
   const [errorMessage, setErrorMessage] = useState<string>('');
   const [showDisconnectButton, setShowDisconnectButton] = useState<boolean>(false);
   const [isGCSActive, setIsGCSActive] = useState<boolean>(false);
-  // const [chunksToBeProces, setChunksToBeProces] = useState<number>(50);
+  const [isNeo4jUser, setNeo4jUser] = useState<boolean>(false);
+
   const value = {
     userCredentials,
     setUserCredentials,
@@ -57,8 +58,8 @@ const UserCredentialsWrapper: FunctionComponent<Props> = (props) => {
     setShowDisconnectButton,
     isGCSActive,
     setIsGCSActive,
-    // chunksToBeProces,
-    // setChunksToBeProces,
+    isNeo4jUser,
+    setNeo4jUser,
   };
   const { pathname } = useLocation();
   useEffect(() => {
diff --git a/frontend/src/services/getChunkText.ts b/frontend/src/services/GetChunkTexts.ts
similarity index 63%
rename from frontend/src/services/getChunkText.ts
rename to frontend/src/services/GetChunkTexts.ts
index c73078b00..97a7c30a9 100644
--- a/frontend/src/services/getChunkText.ts
+++ b/frontend/src/services/GetChunkTexts.ts
@@ -2,14 +2,14 @@ import { chunksData } from '../types';
 import api from '../API/Index';
 
 export const getChunkText = async (documentName: string, page_no: number, signal: AbortSignal) => {
-  const formData = new FormData();
-  formData.append('document_name', documentName);
-  formData.append('page_no', page_no.toString());
   try {
+    const formData = new FormData();
+    formData.append('document_name', documentName);
+    formData.append('page_no', page_no.toString());
     const response = await api.post<chunksData>(`/fetch_chunktext`, formData, { signal });
     return response;
   } catch (error) {
-    console.log(error);
+    console.log(`error in userDetails api, ${error}`);
     throw error;
   }
 };
diff --git a/frontend/src/services/UserDetails.ts b/frontend/src/services/UserDetails.ts
new file mode 100644
index 000000000..dccfccd33
--- /dev/null
+++ b/frontend/src/services/UserDetails.ts
@@ -0,0 +1,16 @@
+import api from '../API/Index';
+import { UserDetailsResponse } from '../types';
+export default async function userDetails() {
+  try {
+    const formData = new FormData();
+    const response = await api.post<UserDetailsResponse>('/user_details', formData, {
+      headers: {
+        'Content-Type': 'multipart/form-data',
+      },
+    });
+    return response.data;
+  } catch (error) {
+    console.log();
+    throw error;
+  }
+}
diff --git a/frontend/src/types.ts b/frontend/src/types.ts
index 72b6ae712..27d110024 100644
--- a/frontend/src/types.ts
+++ b/frontend/src/types.ts
@@ -331,12 +331,20 @@ export interface fileStatus {
   communityNodeCount: number;
   communityRelCount: number;
 }
+interface IUserDetails {
+  is_neo4j_user: boolean;
+  write_access: boolean;
+}
 export interface PollingAPI_Response extends Partial<AxiosResponse> {
   data: statusupdate;
 }
 export interface ServerResponse extends Partial<AxiosResponse> {
   data: URLSCAN_RESPONSE;
 }
+
+export interface UserDetailsResponse extends Partial<commonserverresponse> {
+  data: IUserDetails;
+}
 export interface ScanProps {
   urlParam?: string;
   model?: string;
@@ -393,7 +401,7 @@ interface orphanTotalNodes {
   total: number;
 }
 export interface commonserverresponse {
-  status: string;
+  status: 'Success' | 'Failed';
   error?: string;
   message?: string | orphanTotalNodes;
   file_name?: string;
@@ -403,6 +411,7 @@ export interface commonserverresponse {
     | uploadData
     | orphanNodeProps[]
     | dupNodes[]
+    | IUserDetails
     | { pageitems: chunkdata[]; total_pages: number };
 }
 export interface dupNodeProps {
@@ -762,8 +771,8 @@ export interface ContextProps {
   setShowDisconnectButton: Dispatch<SetStateAction<boolean>>;
   isGCSActive: boolean;
   setIsGCSActive: Dispatch<SetStateAction<boolean>>;
-  // chunksToBeProces: number;
-  // setChunksToBeProces: Dispatch<SetStateAction<number>>;
+  isNeo4jUser: boolean;
+  setNeo4jUser: Dispatch<SetStateAction<boolean>>;
 }
 export interface MessageContextType {
   messages: Messages[] | [];

From 5db5618c9546dc4e5ee9d57ed28b93ad1d51170f Mon Sep 17 00:00:00 2001
From: Pravesh Kumar <121786590+praveshkumar1988@users.noreply.github.com>
Date: Thu, 27 Mar 2025 06:51:15 +0000
Subject: [PATCH 4/8] fix issue

---
 backend/score.py | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/backend/score.py b/backend/score.py
index 508fc67a4..25b3ddba1 100644
--- a/backend/score.py
+++ b/backend/score.py
@@ -1107,7 +1107,7 @@ async def user_details(uri=Form(None),
         start = time.time()
         graph = create_graph_database_connection(uri, userName, password, database)
         graphDb_data_Access = graphDBdataAccess(graph)
-        result = graphDb_data_Access.save_user_details(email)
+        result = graphDb_data_Access.save_user_details(email, database)
         end = time.time()
         elapsed_time = end - start
         return create_api_response('Success', data=result,message=f"Total elapsed API time {elapsed_time:.2f}")

From faf5e7a3fdec501b6edfaa7bd47585cd9e6c131e Mon Sep 17 00:00:00 2001
From: kartikpersistent <101251502+kartikpersistent@users.noreply.github.com>
Date: Thu, 27 Mar 2025 07:43:35 +0000
Subject: [PATCH 5/8] type fixes

---
 frontend/src/components/Content.tsx | 2 +-
 frontend/src/context/UsersFiles.tsx | 2 +-
 2 files changed, 2 insertions(+), 2 deletions(-)

diff --git a/frontend/src/components/Content.tsx b/frontend/src/components/Content.tsx
index e9851ec19..c7113590e 100644
--- a/frontend/src/components/Content.tsx
+++ b/frontend/src/components/Content.tsx
@@ -616,7 +616,7 @@ const Content: React.FC<ContentProps> = ({
       setRetryLoading(true);
       const response = await retry(filename, retryoption);
       setRetryLoading(false);
-      if (response.data.status === 'Failure') {
+      if (response.data.status === 'Failed') {
         throw new Error(response.data.error);
       } else if (
         response.data.status === 'Success' &&
diff --git a/frontend/src/context/UsersFiles.tsx b/frontend/src/context/UsersFiles.tsx
index 5a354ec2f..5fb5181ed 100644
--- a/frontend/src/context/UsersFiles.tsx
+++ b/frontend/src/context/UsersFiles.tsx
@@ -34,7 +34,7 @@ const FileContextProvider: FC<FileContextProviderProps> = ({ children }) => {
   const { userCredentials } = useCredentials();
   const [files, setFiles] = useState<(File | null)[] | []>([]);
   const [filesData, setFilesData] = useState<CustomFile[] | []>([]);
-  const [queue, setQueue] = useState<Queue>(
+  const [queue, setQueue] = useState<Queue<CustomFile>>(
     new Queue(JSON.parse(persistedQueue ?? JSON.stringify({ queue: [] })).queue)
   );
   const [model, setModel] = useState<string>(isProdDefaultModel ? selectedModel : isProdEnv ? PRODMODLES[0] : llms[0]);

From e3cf6ec4fd279ee7c0af2db798080eeff8547fcf Mon Sep 17 00:00:00 2001
From: Pravesh Kumar <121786590+praveshkumar1988@users.noreply.github.com>
Date: Thu, 3 Apr 2025 09:02:54 +0000
Subject: [PATCH 6/8] Create user_info class in accept as param in extraction
 to limit chunks creation etc.

---
 backend/score.py                  | 50 ++++++++++++++++++++++++-------
 backend/src/create_chunks.py      |  5 ++--
 backend/src/entities/user.py      |  8 +++++
 backend/src/graphDB_dataAccess.py |  2 +-
 backend/src/main.py               | 45 ++++++++++++++--------------
 5 files changed, 75 insertions(+), 35 deletions(-)
 create mode 100644 backend/src/entities/user.py

diff --git a/backend/score.py b/backend/score.py
index 25b3ddba1..2254843f2 100644
--- a/backend/score.py
+++ b/backend/score.py
@@ -1,3 +1,4 @@
+from src.entities.user import user_info
 from fastapi import FastAPI, File, UploadFile, Form, Request, HTTPException
 from fastapi_health import health
 from fastapi.middleware.cors import CORSMiddleware
@@ -219,7 +220,7 @@ async def extract_knowledge_graph_from_file(
     retry_condition=Form(None),
     additional_instructions=Form(None),
     email=Form(None),
-    is_neo4j_user=Form(False)
+    user_obj: user_info=Form(None)
 ):
     """
     Calls 'extract_graph_from_file' in a new thread to create Neo4jGraph from a
@@ -242,22 +243,22 @@ async def extract_knowledge_graph_from_file(
         if source_type == 'local file':
             file_name = sanitize_filename(file_name)
             merged_file_path = validate_file_path(MERGED_DIR, file_name)
-            uri_latency, result = await extract_graph_from_file_local_file(uri, userName, password, database, model, merged_file_path, file_name, allowedNodes, allowedRelationship, token_chunk_size, chunk_overlap, chunks_to_combine, retry_condition, additional_instructions, is_neo4j_user)
+            uri_latency, result = await extract_graph_from_file_local_file(uri, userName, password, database, model, merged_file_path, file_name, allowedNodes, allowedRelationship, token_chunk_size, chunk_overlap, chunks_to_combine, retry_condition, additional_instructions, user_obj)
 
         elif source_type == 's3 bucket' and source_url:
-            uri_latency, result = await extract_graph_from_file_s3(uri, userName, password, database, model, source_url, aws_access_key_id, aws_secret_access_key, file_name, allowedNodes, allowedRelationship, token_chunk_size, chunk_overlap, chunks_to_combine, retry_condition, additional_instructions, is_neo4j_user)
+            uri_latency, result = await extract_graph_from_file_s3(uri, userName, password, database, model, source_url, aws_access_key_id, aws_secret_access_key, file_name, allowedNodes, allowedRelationship, token_chunk_size, chunk_overlap, chunks_to_combine, retry_condition, additional_instructions, user_obj)
         
         elif source_type == 'web-url':
-            uri_latency, result = await extract_graph_from_web_page(uri, userName, password, database, model, source_url, file_name, allowedNodes, allowedRelationship, token_chunk_size, chunk_overlap, chunks_to_combine, retry_condition, additional_instructions, is_neo4j_user)
+            uri_latency, result = await extract_graph_from_web_page(uri, userName, password, database, model, source_url, file_name, allowedNodes, allowedRelationship, token_chunk_size, chunk_overlap, chunks_to_combine, retry_condition, additional_instructions, user_obj)
 
         elif source_type == 'youtube' and source_url:
-            uri_latency, result = await extract_graph_from_file_youtube(uri, userName, password, database, model, source_url, file_name, allowedNodes, allowedRelationship, token_chunk_size, chunk_overlap, chunks_to_combine, retry_condition, additional_instructions, is_neo4j_user)
+            uri_latency, result = await extract_graph_from_file_youtube(uri, userName, password, database, model, source_url, file_name, allowedNodes, allowedRelationship, token_chunk_size, chunk_overlap, chunks_to_combine, retry_condition, additional_instructions, user_obj)
 
         elif source_type == 'Wikipedia' and wiki_query:
-            uri_latency, result = await extract_graph_from_file_Wikipedia(uri, userName, password, database, model, wiki_query, language, file_name, allowedNodes, allowedRelationship, token_chunk_size, chunk_overlap, chunks_to_combine, retry_condition, additional_instructions, is_neo4j_user)
+            uri_latency, result = await extract_graph_from_file_Wikipedia(uri, userName, password, database, model, wiki_query, language, file_name, allowedNodes, allowedRelationship, token_chunk_size, chunk_overlap, chunks_to_combine, retry_condition, additional_instructions, user_obj)
 
         elif source_type == 'gcs bucket' and gcs_bucket_name:
-            uri_latency, result = await extract_graph_from_file_gcs(uri, userName, password, database, model, gcs_project_id, gcs_bucket_name, gcs_bucket_folder, gcs_blob_filename, access_token, file_name, allowedNodes, allowedRelationship, token_chunk_size, chunk_overlap, chunks_to_combine, retry_condition, additional_instructions, is_neo4j_user)
+            uri_latency, result = await extract_graph_from_file_gcs(uri, userName, password, database, model, gcs_project_id, gcs_bucket_name, gcs_bucket_folder, gcs_blob_filename, access_token, file_name, allowedNodes, allowedRelationship, token_chunk_size, chunk_overlap, chunks_to_combine, retry_condition, additional_instructions, user_obj)
         else:
             return create_api_response('Failed',message='source_type is other than accepted source')
         extract_api_time = time.time() - start_time
@@ -1097,8 +1098,8 @@ async def get_schema_visualization(uri=Form(None), userName=Form(None), password
     finally:
         gc.collect()
 
-@app.post("/user_details")
-async def user_details(uri=Form(None), 
+@app.post("/set_user_info")
+async def set_user_info(uri=Form(None), 
                     userName=Form(None), 
                     password=Form(None), 
                     database=Form(None), 
@@ -1107,7 +1108,7 @@ async def user_details(uri=Form(None),
         start = time.time()
         graph = create_graph_database_connection(uri, userName, password, database)
         graphDb_data_Access = graphDBdataAccess(graph)
-        result = graphDb_data_Access.save_user_details(email, database)
+        result = graphDb_data_Access.save_user_info(email, database)
         end = time.time()
         elapsed_time = end - start
         return create_api_response('Success', data=result,message=f"Total elapsed API time {elapsed_time:.2f}")
@@ -1120,5 +1121,34 @@ async def user_details(uri=Form(None),
     finally:
         gc.collect()
 
+@app.post("/get_user_info")
+async def get_user_info(uri=Form(None), 
+                    userName=Form(None), 
+                    password=Form(None), 
+                    database=Form(None), 
+                    email=Form(None)):
+    try:
+        start = time.time()
+        graph = create_graph_database_connection(uri, userName, password, database)
+        graphDb_data_Access = graphDBdataAccess(graph)
+        # result = graphDb_data_Access.get_user_detail(email)
+        userInfo = user_info()
+        userInfo.chunk_limits= 100
+        userInfo.readonly= False
+        userInfo.rate_limit= 60000
+        userInfo.remaining_limit = 40000
+        userInfo.is_chunk_limit_applicable = True
+        end = time.time()
+        elapsed_time = end - start
+        return create_api_response('Success', data=userInfo,message=f"Total elapsed API time {elapsed_time:.2f}")
+    except Exception as e:
+        message="Unable to get the details of user in DB"
+        error_message = str(e)
+        logging.info(message)
+        logging.exception(f'Exception:{error_message}')
+        return create_api_response("Failed", message=message, error=error_message)
+    finally:
+        gc.collect()
+
 if __name__ == "__main__":
     uvicorn.run(app)
\ No newline at end of file
diff --git a/backend/src/create_chunks.py b/backend/src/create_chunks.py
index 4657701cd..b058b1121 100644
--- a/backend/src/create_chunks.py
+++ b/backend/src/create_chunks.py
@@ -1,5 +1,6 @@
 from langchain_text_splitters import TokenTextSplitter
 from langchain.docstore.document import Document
+from src.entities.user import user_info
 from langchain_neo4j import Neo4jGraph
 import logging
 from src.document_sources.youtube import get_chunks_with_timestamps, get_calculated_timestamps
@@ -14,7 +15,7 @@ def __init__(self, pages: list[Document], graph: Neo4jGraph):
         self.pages = pages
         self.graph = graph
 
-    def split_file_into_chunks(self,token_chunk_size, chunk_overlap, is_neo4j_user):
+    def split_file_into_chunks(self,token_chunk_size, chunk_overlap, user_obj: user_info):
         """
         Split a list of documents(file pages) into chunks of fixed size.
 
@@ -33,7 +34,7 @@ def split_file_into_chunks(self,token_chunk_size, chunk_overlap, is_neo4j_user):
             chunks = []
             for i, document in enumerate(self.pages):
                 page_number = i + 1
-                if not is_neo4j_user and len(chunks) >= chunk_to_be_created:
+                if user_obj.is_chunk_limit_applicable and (len(chunks) >= user_obj.chunk_limits or user_info.remaining_limit <= 0) or len(chunks) >= chunk_to_be_created:
                     break
                 else:
                     for chunk in text_splitter.split_documents([document]):
diff --git a/backend/src/entities/user.py b/backend/src/entities/user.py
new file mode 100644
index 000000000..907bd01e3
--- /dev/null
+++ b/backend/src/entities/user.py
@@ -0,0 +1,8 @@
+from pydantic import BaseModel
+
+class user_info(BaseModel):
+    chunk_limits:int
+    readonly:bool
+    rate_limit:int
+    remaining_limit:int
+    is_chunk_limit_applicable:bool
\ No newline at end of file
diff --git a/backend/src/graphDB_dataAccess.py b/backend/src/graphDB_dataAccess.py
index 5a729fb59..4c9e4b35f 100644
--- a/backend/src/graphDB_dataAccess.py
+++ b/backend/src/graphDB_dataAccess.py
@@ -585,7 +585,7 @@ def get_websource_url(self,file_name):
         param = {"file_name" : file_name}
         return self.execute_query(query, param)
     
-    def save_user_details(self,email, database):
+    def save_user_info(self,email, database):
         domain = "@neo4j.com"
         is_neo4j_user = domain in email
         write_access = self.check_account_access(database=database)
diff --git a/backend/src/main.py b/backend/src/main.py
index d3859f24d..af0f3d31c 100644
--- a/backend/src/main.py
+++ b/backend/src/main.py
@@ -1,3 +1,4 @@
+from src.entities.user import user_info
 from langchain_neo4j import Neo4jGraph
 from src.shared.constants import (BUCKET_UPLOAD,BUCKET_FAILED_FILE, PROJECT_ID, QUERY_TO_GET_CHUNKS, 
                                   QUERY_TO_DELETE_EXISTING_ENTITIES, 
@@ -226,7 +227,7 @@ def create_source_node_graph_url_wikipedia(graph, model, wiki_query, source_type
       lst_file_name.append({'fileName':obj_source_node.file_name,'fileSize':obj_source_node.file_size,'url':obj_source_node.url, 'language':obj_source_node.language, 'status':'Success'})
     return lst_file_name,success_count,failed_count
     
-async def extract_graph_from_file_local_file(uri, userName, password, database, model, merged_file_path, fileName, allowedNodes, allowedRelationship, token_chunk_size, chunk_overlap, chunks_to_combine, retry_condition, additional_instructions, is_neo4j_user):
+async def extract_graph_from_file_local_file(uri, userName, password, database, model, merged_file_path, fileName, allowedNodes, allowedRelationship, token_chunk_size, chunk_overlap, chunks_to_combine, retry_condition, additional_instructions, user_obj:user_info):
 
   logging.info(f'Process file name :{fileName}')
   if not retry_condition:
@@ -238,11 +239,11 @@ async def extract_graph_from_file_local_file(uri, userName, password, database,
       file_name, pages, file_extension = get_documents_from_file_by_path(merged_file_path,fileName)
     if pages==None or len(pages)==0:
       raise LLMGraphBuilderException(f'File content is not available for file : {file_name}')
-    return await processing_source(uri, userName, password, database, model, file_name, pages, allowedNodes, allowedRelationship, token_chunk_size, chunk_overlap, chunks_to_combine, additional_instructions, is_neo4j_user, is_uploaded_from_local= True, merged_file_path= merged_file_path)
+    return await processing_source(uri, userName, password, database, model, file_name, pages, allowedNodes, allowedRelationship, token_chunk_size, chunk_overlap, chunks_to_combine, additional_instructions, user_obj, is_uploaded_from_local= True, merged_file_path= merged_file_path)
   else:
-    return await processing_source(uri, userName, password, database, model, fileName, [], allowedNodes, allowedRelationship, token_chunk_size, chunk_overlap, chunks_to_combine, additional_instructions, is_neo4j_user, retry_condition, True, merged_file_path)
+    return await processing_source(uri, userName, password, database, model, fileName, [], allowedNodes, allowedRelationship, token_chunk_size, chunk_overlap, chunks_to_combine, additional_instructions, user_obj, retry_condition, True, merged_file_path)
   
-async def extract_graph_from_file_s3(uri, userName, password, database, model, source_url, aws_access_key_id, aws_secret_access_key, file_name, allowedNodes, allowedRelationship, token_chunk_size, chunk_overlap, chunks_to_combine, retry_condition, additional_instructions, is_neo4j_user):
+async def extract_graph_from_file_s3(uri, userName, password, database, model, source_url, aws_access_key_id, aws_secret_access_key, file_name, allowedNodes, allowedRelationship, token_chunk_size, chunk_overlap, chunks_to_combine, retry_condition, additional_instructions, user_obj:user_info):
   if not retry_condition:
     if(aws_access_key_id==None or aws_secret_access_key==None):
       raise LLMGraphBuilderException('Please provide AWS access and secret keys')
@@ -252,48 +253,48 @@ async def extract_graph_from_file_s3(uri, userName, password, database, model, s
 
     if pages==None or len(pages)==0:
       raise LLMGraphBuilderException(f'File content is not available for file : {file_name}')
-    return await processing_source(uri, userName, password, database, model, file_name, pages, allowedNodes, allowedRelationship, token_chunk_size, chunk_overlap, chunks_to_combine, additional_instructions, is_neo4j_user)
+    return await processing_source(uri, userName, password, database, model, file_name, pages, allowedNodes, allowedRelationship, token_chunk_size, chunk_overlap, chunks_to_combine, additional_instructions, user_obj)
   else:
-    return await processing_source(uri, userName, password, database, model, file_name, [], allowedNodes, allowedRelationship, token_chunk_size, chunk_overlap, chunks_to_combine, additional_instructions, is_neo4j_user, retry_condition)
+    return await processing_source(uri, userName, password, database, model, file_name, [], allowedNodes, allowedRelationship, token_chunk_size, chunk_overlap, chunks_to_combine, additional_instructions, user_obj, retry_condition)
   
-async def extract_graph_from_web_page(uri, userName, password, database, model, source_url, file_name, allowedNodes, allowedRelationship, token_chunk_size, chunk_overlap, chunks_to_combine, retry_condition, additional_instructions, is_neo4j_user):
+async def extract_graph_from_web_page(uri, userName, password, database, model, source_url, file_name, allowedNodes, allowedRelationship, token_chunk_size, chunk_overlap, chunks_to_combine, retry_condition, additional_instructions, user_obj:user_info):
   if not retry_condition:
     pages = get_documents_from_web_page(source_url)
     if pages==None or len(pages)==0:
       raise LLMGraphBuilderException(f'Content is not available for given URL : {file_name}')
-    return await processing_source(uri, userName, password, database, model, file_name, pages, allowedNodes, allowedRelationship, token_chunk_size, chunk_overlap, chunks_to_combine, additional_instructions, is_neo4j_user)
+    return await processing_source(uri, userName, password, database, model, file_name, pages, allowedNodes, allowedRelationship, token_chunk_size, chunk_overlap, chunks_to_combine, additional_instructions, user_obj)
   else:
-    return await processing_source(uri, userName, password, database, model, file_name, [], allowedNodes, allowedRelationship, token_chunk_size, chunk_overlap, chunks_to_combine, additional_instructions, is_neo4j_user, retry_condition)
+    return await processing_source(uri, userName, password, database, model, file_name, [], allowedNodes, allowedRelationship, token_chunk_size, chunk_overlap, chunks_to_combine, additional_instructions, user_obj, retry_condition)
   
-async def extract_graph_from_file_youtube(uri, userName, password, database, model, source_url, file_name, allowedNodes, allowedRelationship, token_chunk_size, chunk_overlap, chunks_to_combine, retry_condition, additional_instructions, is_neo4j_user):
+async def extract_graph_from_file_youtube(uri, userName, password, database, model, source_url, file_name, allowedNodes, allowedRelationship, token_chunk_size, chunk_overlap, chunks_to_combine, retry_condition, additional_instructions, user_obj:user_info):
   if not retry_condition:
     file_name, pages = get_documents_from_youtube(source_url)
 
     if pages==None or len(pages)==0:
       raise LLMGraphBuilderException(f'Youtube transcript is not available for file : {file_name}')
-    return await processing_source(uri, userName, password, database, model, file_name, pages, allowedNodes, allowedRelationship, token_chunk_size, chunk_overlap, chunks_to_combine, additional_instructions, is_neo4j_user)
+    return await processing_source(uri, userName, password, database, model, file_name, pages, allowedNodes, allowedRelationship, token_chunk_size, chunk_overlap, chunks_to_combine, additional_instructions, user_obj)
   else:
-     return await processing_source(uri, userName, password, database, model, file_name, [], allowedNodes, allowedRelationship, token_chunk_size, chunk_overlap, chunks_to_combine, additional_instructions, is_neo4j_user, retry_condition)
+     return await processing_source(uri, userName, password, database, model, file_name, [], allowedNodes, allowedRelationship, token_chunk_size, chunk_overlap, chunks_to_combine, additional_instructions, user_obj, retry_condition)
     
-async def extract_graph_from_file_Wikipedia(uri, userName, password, database, model, wiki_query, language, file_name, allowedNodes, allowedRelationship, token_chunk_size, chunk_overlap, chunks_to_combine, retry_condition, additional_instructions, is_neo4j_user):
+async def extract_graph_from_file_Wikipedia(uri, userName, password, database, model, wiki_query, language, file_name, allowedNodes, allowedRelationship, token_chunk_size, chunk_overlap, chunks_to_combine, retry_condition, additional_instructions, user_obj:user_info):
   if not retry_condition:
     file_name, pages = get_documents_from_Wikipedia(wiki_query, language)
     if pages==None or len(pages)==0:
       raise LLMGraphBuilderException(f'Wikipedia page is not available for file : {file_name}')
-    return await processing_source(uri, userName, password, database, model, file_name, pages, allowedNodes, allowedRelationship, token_chunk_size, chunk_overlap, chunks_to_combine, additional_instructions, is_neo4j_user)
+    return await processing_source(uri, userName, password, database, model, file_name, pages, allowedNodes, allowedRelationship, token_chunk_size, chunk_overlap, chunks_to_combine, additional_instructions, user_obj)
   else:
-    return await processing_source(uri, userName, password, database, model, file_name,[], allowedNodes, allowedRelationship, token_chunk_size, chunk_overlap, chunks_to_combine, additional_instructions, is_neo4j_user, retry_condition)
+    return await processing_source(uri, userName, password, database, model, file_name,[], allowedNodes, allowedRelationship, token_chunk_size, chunk_overlap, chunks_to_combine, additional_instructions, user_obj, retry_condition)
 
-async def extract_graph_from_file_gcs(uri, userName, password, database, model, gcs_project_id, gcs_bucket_name, gcs_bucket_folder, gcs_blob_filename, access_token, file_name, allowedNodes, allowedRelationship, token_chunk_size, chunk_overlap, chunks_to_combine, retry_condition, additional_instructions, is_neo4j_user):
+async def extract_graph_from_file_gcs(uri, userName, password, database, model, gcs_project_id, gcs_bucket_name, gcs_bucket_folder, gcs_blob_filename, access_token, file_name, allowedNodes, allowedRelationship, token_chunk_size, chunk_overlap, chunks_to_combine, retry_condition, additional_instructions, user_obj:user_info):
   if not retry_condition:
     file_name, pages = get_documents_from_gcs(gcs_project_id, gcs_bucket_name, gcs_bucket_folder, gcs_blob_filename, access_token)
     if pages==None or len(pages)==0:
       raise LLMGraphBuilderException(f'File content is not available for file : {file_name}')
-    return await processing_source(uri, userName, password, database, model, file_name, pages, allowedNodes, allowedRelationship, token_chunk_size, chunk_overlap, chunks_to_combine, additional_instructions, is_neo4j_user)
+    return await processing_source(uri, userName, password, database, model, file_name, pages, allowedNodes, allowedRelationship, token_chunk_size, chunk_overlap, chunks_to_combine, additional_instructions, user_obj)
   else:
-    return await processing_source(uri, userName, password, database, model, file_name, [], allowedNodes, allowedRelationship, token_chunk_size, chunk_overlap, chunks_to_combine, additional_instructions, is_neo4j_user, retry_condition)
+    return await processing_source(uri, userName, password, database, model, file_name, [], allowedNodes, allowedRelationship, token_chunk_size, chunk_overlap, chunks_to_combine, additional_instructions, user_obj, retry_condition)
   
-async def processing_source(uri, userName, password, database, model, file_name, pages, allowedNodes, allowedRelationship, token_chunk_size, chunk_overlap, chunks_to_combine, additional_instructions, is_neo4j_user, retry_condition = None, is_uploaded_from_local=False, merged_file_path=None):
+async def processing_source(uri, userName, password, database, model, file_name, pages, allowedNodes, allowedRelationship, token_chunk_size, chunk_overlap, chunks_to_combine, additional_instructions, user_obj:user_info, retry_condition = None, is_uploaded_from_local=False, merged_file_path=None):
   """
    Extracts a Neo4jGraph from a PDF file based on the model.
    
@@ -322,7 +323,7 @@ async def processing_source(uri, userName, password, database, model, file_name,
   graphDb_data_Access = graphDBdataAccess(graph)
   create_chunk_vector_index(graph)
   start_get_chunkId_chunkDoc_list = time.time()
-  total_chunks, chunkId_chunkDoc_list = get_chunkId_chunkDoc_list(graph, file_name, pages, token_chunk_size, chunk_overlap, retry_condition, is_neo4j_user)
+  total_chunks, chunkId_chunkDoc_list = get_chunkId_chunkDoc_list(graph, file_name, pages, token_chunk_size, chunk_overlap, retry_condition, user_obj)
   end_get_chunkId_chunkDoc_list = time.time()
   elapsed_get_chunkId_chunkDoc_list = end_get_chunkId_chunkDoc_list - start_get_chunkId_chunkDoc_list
   logging.info(f'Time taken to create list chunkids with chunk document: {elapsed_get_chunkId_chunkDoc_list:.2f} seconds')
@@ -509,7 +510,7 @@ async def processing_chunks(chunkId_chunkDoc_list,graph,uri, userName, password,
   rel_count = count_response[file_name].get('relationshipCount',"0")
   return node_count,rel_count,latency_processing_chunk
 
-def get_chunkId_chunkDoc_list(graph, file_name, pages, token_chunk_size, chunk_overlap, retry_condition, is_neo4j_user):
+def get_chunkId_chunkDoc_list(graph, file_name, pages, token_chunk_size, chunk_overlap, retry_condition, user_obj: user_info):
   if not retry_condition:
     logging.info("Break down file into chunks")
     bad_chars = ['"', "\n", "'"]
@@ -522,7 +523,7 @@ def get_chunkId_chunkDoc_list(graph, file_name, pages, token_chunk_size, chunk_o
           text = text.replace(j, '')
       pages[i]=Document(page_content=str(text), metadata=pages[i].metadata)
     create_chunks_obj = CreateChunksofDocument(pages, graph)
-    chunks = create_chunks_obj.split_file_into_chunks(token_chunk_size, chunk_overlap, is_neo4j_user)
+    chunks = create_chunks_obj.split_file_into_chunks(token_chunk_size, chunk_overlap, user_obj)
     chunkId_chunkDoc_list = create_relation_between_chunks(graph,file_name,chunks)
     return len(chunks), chunkId_chunkDoc_list
   

From 1947a2044d104b01ae38bd4b76382409f959739e Mon Sep 17 00:00:00 2001
From: Pravesh Kumar <121786590+praveshkumar1988@users.noreply.github.com>
Date: Fri, 4 Apr 2025 07:50:46 +0000
Subject: [PATCH 7/8] Issue fixed

---
 backend/score.py             |  6 ++++--
 backend/src/entities/user.py | 11 ++++++-----
 2 files changed, 10 insertions(+), 7 deletions(-)

diff --git a/backend/score.py b/backend/score.py
index 2254843f2..05db07378 100644
--- a/backend/score.py
+++ b/backend/score.py
@@ -1126,20 +1126,22 @@ async def get_user_info(uri=Form(None),
                     userName=Form(None), 
                     password=Form(None), 
                     database=Form(None), 
-                    email=Form(None)):
+                    email=Form(None),
+                    token_chunk_size:int=Form(None)):
     try:
         start = time.time()
         graph = create_graph_database_connection(uri, userName, password, database)
         graphDb_data_Access = graphDBdataAccess(graph)
         # result = graphDb_data_Access.get_user_detail(email)
         userInfo = user_info()
-        userInfo.chunk_limits= 100
+        userInfo.chunk_limits= 200
         userInfo.readonly= False
         userInfo.rate_limit= 60000
         userInfo.remaining_limit = 40000
         userInfo.is_chunk_limit_applicable = True
         end = time.time()
         elapsed_time = end - start
+        logger.log_struct(userInfo, "INFO")
         return create_api_response('Success', data=userInfo,message=f"Total elapsed API time {elapsed_time:.2f}")
     except Exception as e:
         message="Unable to get the details of user in DB"
diff --git a/backend/src/entities/user.py b/backend/src/entities/user.py
index 907bd01e3..26d176de8 100644
--- a/backend/src/entities/user.py
+++ b/backend/src/entities/user.py
@@ -1,8 +1,9 @@
 from pydantic import BaseModel
+from typing import Optional
 
 class user_info(BaseModel):
-    chunk_limits:int
-    readonly:bool
-    rate_limit:int
-    remaining_limit:int
-    is_chunk_limit_applicable:bool
\ No newline at end of file
+    chunk_limits:Optional[int] = 50
+    readonly:Optional[bool] = False
+    rate_limit:Optional[int] = 100000
+    remaining_limit:Optional[int] = 100000
+    is_chunk_limit_applicable:Optional[bool] = True
\ No newline at end of file

From c62ec61f44edc6e7fb731219498c7507321701cc Mon Sep 17 00:00:00 2001
From: Pravesh Kumar <121786590+praveshkumar1988@users.noreply.github.com>
Date: Fri, 4 Apr 2025 08:01:02 +0000
Subject: [PATCH 8/8] chunks_limit from config file

---
 backend/score.py | 4 +++-
 1 file changed, 3 insertions(+), 1 deletion(-)

diff --git a/backend/score.py b/backend/score.py
index 05db07378..6d3ffd0e6 100644
--- a/backend/score.py
+++ b/backend/score.py
@@ -1133,8 +1133,10 @@ async def get_user_info(uri=Form(None),
         graph = create_graph_database_connection(uri, userName, password, database)
         graphDb_data_Access = graphDBdataAccess(graph)
         # result = graphDb_data_Access.get_user_detail(email)
+        MAX_TOKEN_CHUNK_SIZE = int(os.getenv('MAX_TOKEN_CHUNK_SIZE', 10000))
+        chunk_to_be_created = int(MAX_TOKEN_CHUNK_SIZE / int(token_chunk_size))
         userInfo = user_info()
-        userInfo.chunk_limits= 200
+        userInfo.chunk_limits= chunk_to_be_created
         userInfo.readonly= False
         userInfo.rate_limit= 60000
         userInfo.remaining_limit = 40000