llm-ie 1.0.0__py3-none-any.whl → 1.2.0__py3-none-any.whl

llm_ie/extractors.py

@@ -17,7 +17,7 @@ from colorama import Fore, Style
 
 
 class Extractor:
-    def __init__(self, inference_engine:InferenceEngine, prompt_template:str, system_prompt:str=None, **kwrs):
+    def __init__(self, inference_engine:InferenceEngine, prompt_template:str, system_prompt:str=None):
         """
         This is the abstract class for (frame and relation) extractors.
         Input LLM inference engine, system prompt (optional), prompt template (with instruction, few-shot examples).
@@ -172,7 +172,7 @@ class Extractor:
 class FrameExtractor(Extractor):
     from nltk.tokenize import RegexpTokenizer
     def __init__(self, inference_engine:InferenceEngine, unit_chunker:UnitChunker, 
-                 prompt_template:str, system_prompt:str=None, context_chunker:ContextChunker=None, **kwrs):
+                 prompt_template:str, system_prompt:str=None, context_chunker:ContextChunker=None):
         """
         This is the abstract class for frame extraction.
         Input LLM inference engine, system prompt (optional), prompt template (with instruction, few-shot examples).
@@ -192,8 +192,7 @@ class FrameExtractor(Extractor):
         """
         super().__init__(inference_engine=inference_engine,
                          prompt_template=prompt_template,
-                         system_prompt=system_prompt,
-                         **kwrs)
+                         system_prompt=system_prompt)
                 
         self.unit_chunker = unit_chunker
         if context_chunker is None:
@@ -332,7 +331,7 @@ class FrameExtractor(Extractor):
         return entity_spans
 
     @abc.abstractmethod
-    def extract(self, text_content:Union[str, Dict[str,str]], max_new_tokens:int=2048, return_messages_log:bool=False, **kwrs) -> str:
+    def extract(self, text_content:Union[str, Dict[str,str]], return_messages_log:bool=False, **kwrs) -> str:
         """
         This method inputs text content and outputs a string generated by LLM
 
@@ -342,8 +341,6 @@ class FrameExtractor(Extractor):
             the input text content to put in prompt template. 
             If str, the prompt template must has only 1 placeholder {{<placeholder name>}}, regardless of placeholder name.
             If dict, all the keys must be included in the prompt template placeholder {{<placeholder name>}}.
-        max_new_tokens : str, Optional
-            the max number of new tokens LLM can generate. 
         return_messages_log : bool, Optional
             if True, a list of messages will be returned.
 
@@ -354,7 +351,7 @@ class FrameExtractor(Extractor):
     
     
     @abc.abstractmethod
-    def extract_frames(self, text_content:Union[str, Dict[str,str]], entity_key:str, max_new_tokens:int=2048, 
+    def extract_frames(self, text_content:Union[str, Dict[str,str]], entity_key:str, 
                        document_key:str=None, return_messages_log:bool=False, **kwrs) -> List[LLMInformationExtractionFrame]:
         """
         This method inputs text content and outputs a list of LLMInformationExtractionFrame
@@ -368,8 +365,6 @@ class FrameExtractor(Extractor):
             If dict, all the keys must be included in the prompt template placeholder {{<placeholder name>}}.
         entity_key : str
             the key (in ouptut JSON) for entity text. Any extraction that does not include entity key will be dropped.
-        max_new_tokens : str, Optional
-            the max number of new tokens LLM should generate. 
         document_key : str, Optional
             specify the key in text_content where document text is. 
             If text_content is str, this parameter will be ignored.
@@ -384,7 +379,7 @@ class FrameExtractor(Extractor):
 
 class DirectFrameExtractor(FrameExtractor):
     def __init__(self, inference_engine:InferenceEngine, unit_chunker:UnitChunker, 
-                 prompt_template:str, system_prompt:str=None, context_chunker:ContextChunker=None, **kwrs):
+                 prompt_template:str, system_prompt:str=None, context_chunker:ContextChunker=None):
         """
         This class is for general unit-context frame extraction.
         Input LLM inference engine, system prompt (optional), prompt template (with instruction, few-shot examples).
@@ -406,12 +401,11 @@ class DirectFrameExtractor(FrameExtractor):
                          unit_chunker=unit_chunker,
                          prompt_template=prompt_template,
                          system_prompt=system_prompt,
-                         context_chunker=context_chunker,
-                         **kwrs)
+                         context_chunker=context_chunker)
 
 
-    def extract(self, text_content:Union[str, Dict[str,str]], max_new_tokens:int=2048, 
-                document_key:str=None, temperature:float=0.0, verbose:bool=False, return_messages_log:bool=False, **kwrs) -> List[FrameExtractionUnitResult]:
+    def extract(self, text_content:Union[str, Dict[str,str]], 
+                document_key:str=None, verbose:bool=False, return_messages_log:bool=False) -> List[FrameExtractionUnitResult]:
         """
         This method inputs a text and outputs a list of outputs per unit.
 
@@ -421,13 +415,9 @@ class DirectFrameExtractor(FrameExtractor):
             the input text content to put in prompt template. 
             If str, the prompt template must has only 1 placeholder {{<placeholder name>}}, regardless of placeholder name.
             If dict, all the keys must be included in the prompt template placeholder {{<placeholder name>}}.
-        max_new_tokens : int, Optional
-            the max number of new tokens LLM should generate. 
         document_key : str, Optional
             specify the key in text_content where document text is. 
             If text_content is str, this parameter will be ignored.
-        temperature : float, Optional
-            the temperature for token sampling.
         verbose : bool, Optional
             if True, LLM generated text will be printed in terminal in real-time. 
         return_messages_log : bool, Optional
@@ -491,27 +481,12 @@ class DirectFrameExtractor(FrameExtractor):
                 
                 print(f"{Fore.BLUE}Extraction:{Style.RESET_ALL}")
 
-                response_stream = self.inference_engine.chat(
-                                messages=messages, 
-                                max_new_tokens=max_new_tokens, 
-                                temperature=temperature,
-                                stream=True,
-                                **kwrs
-                            )
-                
-                gen_text = ""
-                for chunk in response_stream:
-                    gen_text += chunk
-                    print(chunk, end='', flush=True)
             
-            else:
-                gen_text = self.inference_engine.chat(
-                                messages=messages, 
-                                max_new_tokens=max_new_tokens, 
-                                temperature=temperature,
-                                stream=False,
-                                **kwrs
-                            )
+            gen_text = self.inference_engine.chat(
+                            messages=messages, 
+                            verbose=verbose,
+                            stream=False
+                        )
 
             if return_messages_log:
                 messages.append({"role": "assistant", "content": gen_text})
@@ -530,8 +505,8 @@ class DirectFrameExtractor(FrameExtractor):
         
         return output
     
-    def stream(self, text_content: Union[str, Dict[str, str]], max_new_tokens: int = 2048, document_key: str = None, 
-               temperature: float = 0.0, **kwrs) -> Generator[Dict[str, Any], None, List[FrameExtractionUnitResult]]:
+    def stream(self, text_content: Union[str, Dict[str, str]], 
+               document_key: str = None) -> Generator[Dict[str, Any], None, List[FrameExtractionUnitResult]]:
         """
         Streams LLM responses per unit with structured event types,
         and returns collected data for post-processing.
@@ -542,7 +517,8 @@ class DirectFrameExtractor(FrameExtractor):
             - {"type": "info", "data": str_message}: General informational messages.
             - {"type": "unit", "data": dict_unit_info}: Signals start of a new unit. dict_unit_info contains {'id', 'text', 'start', 'end'}
             - {"type": "context", "data": str_context}: Context string for the current unit.
-            - {"type": "llm_chunk", "data": str_chunk}: A raw chunk from the LLM.
+            - {"type": "reasoning", "data": str_chunk}: A reasoning model thinking chunk from the LLM.
+            - {"type": "response", "data": str_chunk}: A response/answer chunk from the LLM.
 
         Returns:
         --------
@@ -601,13 +577,10 @@ class DirectFrameExtractor(FrameExtractor):
 
             response_stream = self.inference_engine.chat(
                 messages=messages,
-                max_new_tokens=max_new_tokens,
-                temperature=temperature,
-                stream=True,
-                **kwrs
+                stream=True
             )
             for chunk in response_stream:
-                yield {"type": "llm_chunk", "data": chunk}
+                yield chunk
                 current_gen_text += chunk
            
             # Store the result for this unit
@@ -622,8 +595,8 @@ class DirectFrameExtractor(FrameExtractor):
         yield {"type": "info", "data": "All units processed by LLM."}
         return collected_results
 
-    async def extract_async(self, text_content:Union[str, Dict[str,str]], max_new_tokens:int=2048, document_key:str=None, temperature:float=0.0, 
-                            concurrent_batch_size:int=32, return_messages_log:bool=False, **kwrs) -> List[FrameExtractionUnitResult]:
+    async def extract_async(self, text_content:Union[str, Dict[str,str]], document_key:str=None, 
+                            concurrent_batch_size:int=32, return_messages_log:bool=False) -> List[FrameExtractionUnitResult]:
         """
         This is the asynchronous version of the extract() method.
 
@@ -633,13 +606,9 @@ class DirectFrameExtractor(FrameExtractor):
             the input text content to put in prompt template. 
             If str, the prompt template must has only 1 placeholder {{<placeholder name>}}, regardless of placeholder name.
             If dict, all the keys must be included in the prompt template placeholder {{<placeholder name>}}.
-        max_new_tokens : int, Optional
-            the max number of new tokens LLM should generate. 
         document_key : str, Optional
             specify the key in text_content where document text is. 
             If text_content is str, this parameter will be ignored.
-        temperature : float, Optional
-            the temperature for token sampling.
         concurrent_batch_size : int, Optional
             the batch size for concurrent processing. 
         return_messages_log : bool, Optional
@@ -701,17 +670,14 @@ class DirectFrameExtractor(FrameExtractor):
         # Process units concurrently with asyncio.Semaphore
         semaphore = asyncio.Semaphore(concurrent_batch_size)
 
-        async def semaphore_helper(task_data: Dict, max_new_tokens: int, temperature: float, **kwrs):
+        async def semaphore_helper(task_data: Dict, **kwrs):
             unit = task_data["unit"]
             messages = task_data["messages"]
             original_index = task_data["original_index"]
 
             async with semaphore:
                 gen_text = await self.inference_engine.chat_async(
-                    messages=messages,
-                    max_new_tokens=max_new_tokens,
-                    temperature=temperature,
-                    **kwrs
+                    messages=messages
                 )
             return {"original_index": original_index, "unit": unit, "gen_text": gen_text, "messages": messages}
            
@@ -719,10 +685,7 @@ class DirectFrameExtractor(FrameExtractor):
         tasks = []
         for task_inp in tasks_input:
             task = asyncio.create_task(semaphore_helper(
-                task_inp,
-                max_new_tokens=max_new_tokens,
-                temperature=temperature,
-                **kwrs
+                task_inp
             ))
             tasks.append(task)
 
@@ -759,11 +722,10 @@ class DirectFrameExtractor(FrameExtractor):
             return output
 
 
-    def extract_frames(self, text_content:Union[str, Dict[str,str]], max_new_tokens:int=512, 
-                        document_key:str=None, temperature:float=0.0, verbose:bool=False, 
-                        concurrent:bool=False, concurrent_batch_size:int=32,
+    def extract_frames(self, text_content:Union[str, Dict[str,str]], document_key:str=None, 
+                       verbose:bool=False, concurrent:bool=False, concurrent_batch_size:int=32,
                         case_sensitive:bool=False, fuzzy_match:bool=True, fuzzy_buffer_size:float=0.2, fuzzy_score_cutoff:float=0.8,
-                        allow_overlap_entities:bool=False, return_messages_log:bool=False, **kwrs) -> List[LLMInformationExtractionFrame]:
+                        allow_overlap_entities:bool=False, return_messages_log:bool=False) -> List[LLMInformationExtractionFrame]:
         """
         This method inputs a text and outputs a list of LLMInformationExtractionFrame
         It use the extract() method and post-process outputs into frames.
@@ -774,13 +736,9 @@ class DirectFrameExtractor(FrameExtractor):
             the input text content to put in prompt template. 
             If str, the prompt template must has only 1 placeholder {{<placeholder name>}}, regardless of placeholder name.
             If dict, all the keys must be included in the prompt template placeholder {{<placeholder name>}}.
-        max_new_tokens : str, Optional
-            the max number of new tokens LLM should generate. 
         document_key : str, Optional
             specify the key in text_content where document text is. 
             If text_content is str, this parameter will be ignored.
-        temperature : float, Optional
-            the temperature for token sampling.
         verbose : bool, Optional
             if True, LLM generated text will be printed in terminal in real-time. 
         concurrent : bool, Optional
@@ -812,21 +770,15 @@ class DirectFrameExtractor(FrameExtractor):
 
             nest_asyncio.apply() # For Jupyter notebook. Terminal does not need this.
             extraction_results = asyncio.run(self.extract_async(text_content=text_content, 
-                                                max_new_tokens=max_new_tokens, 
                                                 document_key=document_key,
-                                                temperature=temperature, 
                                                 concurrent_batch_size=concurrent_batch_size,
-                                                return_messages_log=return_messages_log,
-                                                **kwrs)
+                                                return_messages_log=return_messages_log)
                                             )
         else:
             extraction_results = self.extract(text_content=text_content, 
-                                                max_new_tokens=max_new_tokens, 
                                                 document_key=document_key,
-                                                temperature=temperature, 
                                                 verbose=verbose,
-                                                return_messages_log=return_messages_log,
-                                                **kwrs)
+                                                return_messages_log=return_messages_log)
             
         llm_output_results, messages_log = extraction_results if return_messages_log else (extraction_results, None)
         
@@ -869,8 +821,8 @@ class DirectFrameExtractor(FrameExtractor):
         
 
 class ReviewFrameExtractor(DirectFrameExtractor):
-    def __init__(self, unit_chunker:UnitChunker, context_chunker:ContextChunker, 
-                 inference_engine:InferenceEngine, prompt_template:str, review_mode:str, review_prompt:str=None, system_prompt:str=None, **kwrs):
+    def __init__(self, unit_chunker:UnitChunker, context_chunker:ContextChunker, inference_engine:InferenceEngine, 
+                 prompt_template:str, review_mode:str, review_prompt:str=None, system_prompt:str=None):
         """
         This class add a review step after the DirectFrameExtractor.
         The Review process asks LLM to review its output and:
@@ -901,8 +853,7 @@ class ReviewFrameExtractor(DirectFrameExtractor):
                          unit_chunker=unit_chunker, 
                          prompt_template=prompt_template, 
                          system_prompt=system_prompt, 
-                         context_chunker=context_chunker,
-                         **kwrs)
+                         context_chunker=context_chunker)
         # check review mode
         if review_mode not in {"addition", "revision"}: 
             raise ValueError('review_mode must be one of {"addition", "revision"}.')
@@ -939,8 +890,8 @@ class ReviewFrameExtractor(DirectFrameExtractor):
         if self.review_prompt is None:
             raise ValueError(f"Cannot find review prompt for {self.__class__.__name__} in the package. Please provide a review_prompt.")
 
-    def extract(self, text_content:Union[str, Dict[str,str]], max_new_tokens:int=2048, document_key:str=None, 
-                temperature:float=0.0, verbose:bool=False, return_messages_log:bool=False, **kwrs) -> List[FrameExtractionUnitResult]:
+    def extract(self, text_content:Union[str, Dict[str,str]], document_key:str=None, 
+                verbose:bool=False, return_messages_log:bool=False) -> List[FrameExtractionUnitResult]:
         """
         This method inputs a text and outputs a list of outputs per unit.
 
@@ -950,13 +901,9 @@ class ReviewFrameExtractor(DirectFrameExtractor):
             the input text content to put in prompt template. 
             If str, the prompt template must has only 1 placeholder {{<placeholder name>}}, regardless of placeholder name.
             If dict, all the keys must be included in the prompt template placeholder {{<placeholder name>}}.
-        max_new_tokens : int, Optional
-            the max number of new tokens LLM should generate. 
         document_key : str, Optional
             specify the key in text_content where document text is. 
             If text_content is str, this parameter will be ignored.
-        temperature : float, Optional
-            the temperature for token sampling.
         verbose : bool, Optional
             if True, LLM generated text will be printed in terminal in real-time. 
         return_messages_log : bool, Optional
@@ -1020,28 +967,13 @@ class ReviewFrameExtractor(DirectFrameExtractor):
                     print(f"{Fore.YELLOW}Context:{Style.RESET_ALL}\n{context}\n")
                 
                 print(f"{Fore.BLUE}Extraction:{Style.RESET_ALL}")
-
-                response_stream = self.inference_engine.chat(
-                                messages=messages, 
-                                max_new_tokens=max_new_tokens, 
-                                temperature=temperature,
-                                stream=True,
-                                **kwrs
-                            )
-                
-                initial = ""
-                for chunk in response_stream:
-                    initial += chunk
-                    print(chunk, end='', flush=True)
             
-            else:
-                initial = self.inference_engine.chat(
-                                messages=messages, 
-                                max_new_tokens=max_new_tokens, 
-                                temperature=temperature,
-                                stream=False,
-                                **kwrs
-                            )
+
+            initial = self.inference_engine.chat(
+                            messages=messages, 
+                            verbose=verbose,
+                            stream=False
+                        )
 
             if return_messages_log:
                 messages.append({"role": "assistant", "content": initial})
@@ -1053,29 +985,12 @@ class ReviewFrameExtractor(DirectFrameExtractor):
 
             messages.append({'role': 'assistant', 'content': initial})
             messages.append({'role': 'user', 'content': self.review_prompt})
-
-            if verbose:
-                response_stream = self.inference_engine.chat(
-                                messages=messages, 
-                                max_new_tokens=max_new_tokens, 
-                                temperature=temperature,
-                                stream=True,
-                                **kwrs
-                            )
-                
-                review = ""
-                for chunk in response_stream:
-                    review += chunk
-                    print(chunk, end='', flush=True)
             
-            else:
-                review = self.inference_engine.chat(
-                                messages=messages, 
-                                max_new_tokens=max_new_tokens, 
-                                temperature=temperature,
-                                stream=False,
-                                **kwrs
-                            )
+            review = self.inference_engine.chat(
+                            messages=messages, 
+                            verbose=verbose,
+                            stream=False
+                        )
 
             # Output
             if self.review_mode == "revision":
@@ -1101,8 +1016,7 @@ class ReviewFrameExtractor(DirectFrameExtractor):
         return output
 
 
-    def stream(self, text_content:Union[str, Dict[str,str]], max_new_tokens:int=2048, 
-               document_key:str=None, temperature:float=0.0, **kwrs) -> Generator[str, None, None]:
+    def stream(self, text_content:Union[str, Dict[str,str]], document_key:str=None) -> Generator[str, None, None]:
         """
         This method inputs a text and outputs a list of outputs per unit.
 
@@ -1112,13 +1026,9 @@ class ReviewFrameExtractor(DirectFrameExtractor):
             the input text content to put in prompt template. 
             If str, the prompt template must has only 1 placeholder {{<placeholder name>}}, regardless of placeholder name.
             If dict, all the keys must be included in the prompt template placeholder {{<placeholder name>}}.
-        max_new_tokens : int, Optional
-            the max number of new tokens LLM should generate. 
         document_key : str, Optional
             specify the key in text_content where document text is. 
             If text_content is str, this parameter will be ignored.
-        temperature : float, Optional
-            the temperature for token sampling.
 
         Return : List[FrameExtractionUnitResult]
             the output from LLM for each unit. Contains the start, end, text, and generated text.
@@ -1176,10 +1086,7 @@ class ReviewFrameExtractor(DirectFrameExtractor):
 
             response_stream = self.inference_engine.chat(
                             messages=messages, 
-                            max_new_tokens=max_new_tokens, 
-                            temperature=temperature,
-                            stream=True,
-                            **kwrs
+                            stream=True
                         )
             
             initial = ""
@@ -1195,16 +1102,13 @@ class ReviewFrameExtractor(DirectFrameExtractor):
 
             response_stream = self.inference_engine.chat(
                             messages=messages, 
-                            max_new_tokens=max_new_tokens, 
-                            temperature=temperature,
-                            stream=True,
-                            **kwrs
+                            stream=True
                         )
             
             for chunk in response_stream:
                 yield chunk
 
-    async def extract_async(self, text_content:Union[str, Dict[str,str]], max_new_tokens:int=2048, document_key:str=None, temperature:float=0.0,
+    async def extract_async(self, text_content:Union[str, Dict[str,str]], document_key:str=None,
                             concurrent_batch_size:int=32, return_messages_log:bool=False, **kwrs) -> List[FrameExtractionUnitResult]:
         """
         This is the asynchronous version of the extract() method with the review step.
@@ -1215,13 +1119,9 @@ class ReviewFrameExtractor(DirectFrameExtractor):
             the input text content to put in prompt template.
             If str, the prompt template must has only 1 placeholder {{<placeholder name>}}, regardless of placeholder name.
             If dict, all the keys must be included in the prompt template placeholder {{<placeholder name>}}.
-        max_new_tokens : int, Optional
-            the max number of new tokens LLM should generate.
         document_key : str, Optional
             specify the key in text_content where document text is.
             If text_content is str, this parameter will be ignored.
-        temperature : float, Optional
-            the temperature for token sampling.
         concurrent_batch_size : int, Optional
             the batch size for concurrent processing.
         return_messages_log : bool, Optional
@@ -1282,17 +1182,14 @@ class ReviewFrameExtractor(DirectFrameExtractor):
 
         semaphore = asyncio.Semaphore(concurrent_batch_size)
 
-        async def initial_semaphore_helper(task_data: Dict, max_new_tokens: int, temperature: float, **kwrs):
+        async def initial_semaphore_helper(task_data: Dict):
             unit = task_data["unit"]
             messages = task_data["messages"]
             original_index = task_data["original_index"]
 
             async with semaphore:
                 gen_text = await self.inference_engine.chat_async(
-                    messages=messages,
-                    max_new_tokens=max_new_tokens,
-                    temperature=temperature,
-                    **kwrs
+                    messages=messages
                 )
             # Return initial generation result along with the messages used and the unit
             return {"original_index": original_index, "unit": unit, "initial_gen_text": gen_text, "initial_messages": messages}
@@ -1300,10 +1197,7 @@ class ReviewFrameExtractor(DirectFrameExtractor):
         # Create and gather initial generation tasks
         initial_tasks = [
             asyncio.create_task(initial_semaphore_helper(
-                task_inp,
-                max_new_tokens=max_new_tokens,
-                temperature=temperature,
-                **kwrs
+                task_inp
             ))
             for task_inp in initial_tasks_input
         ]
@@ -1333,16 +1227,13 @@ class ReviewFrameExtractor(DirectFrameExtractor):
             })
 
 
-        async def review_semaphore_helper(task_data: Dict, max_new_tokens: int, temperature: float, **kwrs):
+        async def review_semaphore_helper(task_data: Dict, **kwrs):
             messages = task_data["messages"] 
             original_index = task_data["original_index"]
 
             async with semaphore:
                 review_gen_text = await self.inference_engine.chat_async(
-                    messages=messages,
-                    max_new_tokens=max_new_tokens,
-                    temperature=temperature,
-                    **kwrs
+                    messages=messages
                 )
             # Combine initial and review results
             task_data["review_gen_text"] = review_gen_text
@@ -1354,10 +1245,7 @@ class ReviewFrameExtractor(DirectFrameExtractor):
         # Create and gather review tasks
         review_tasks = [
              asyncio.create_task(review_semaphore_helper(
-                task_inp,
-                max_new_tokens=max_new_tokens,
-                temperature=temperature,
-                **kwrs
+                task_inp
             ))
            for task_inp in review_tasks_input
         ]
@@ -1405,7 +1293,7 @@ class ReviewFrameExtractor(DirectFrameExtractor):
 
 
 class BasicFrameExtractor(DirectFrameExtractor):
-    def __init__(self, inference_engine:InferenceEngine, prompt_template:str, system_prompt:str=None, **kwrs):
+    def __init__(self, inference_engine:InferenceEngine, prompt_template:str, system_prompt:str=None):
         """
         This class diretly prompt LLM for frame extraction.
         Input system prompt (optional), prompt template (with instruction, few-shot examples), 
@@ -1424,11 +1312,10 @@ class BasicFrameExtractor(DirectFrameExtractor):
                          unit_chunker=WholeDocumentUnitChunker(),
                          prompt_template=prompt_template, 
                          system_prompt=system_prompt, 
-                         context_chunker=NoContextChunker(),
-                         **kwrs)
+                         context_chunker=NoContextChunker())
         
 class BasicReviewFrameExtractor(ReviewFrameExtractor):
-    def __init__(self, inference_engine:InferenceEngine, prompt_template:str, review_mode:str, review_prompt:str=None, system_prompt:str=None, **kwrs):
+    def __init__(self, inference_engine:InferenceEngine, prompt_template:str, review_mode:str, review_prompt:str=None, system_prompt:str=None):
         """
         This class add a review step after the BasicFrameExtractor.
         The Review process asks LLM to review its output and:
@@ -1457,13 +1344,12 @@ class BasicReviewFrameExtractor(ReviewFrameExtractor):
                          review_mode=review_mode,
                          review_prompt=review_prompt,
                          system_prompt=system_prompt, 
-                         context_chunker=NoContextChunker(),
-                         **kwrs)
+                         context_chunker=NoContextChunker())
         
 
 class SentenceFrameExtractor(DirectFrameExtractor):
     def __init__(self, inference_engine:InferenceEngine, prompt_template:str, system_prompt:str=None,
-                 context_sentences:Union[str, int]="all", **kwrs):
+                 context_sentences:Union[str, int]="all"):
         """
         This class performs sentence-by-sentence information extraction.
         The process is as follows:
@@ -1507,14 +1393,13 @@ class SentenceFrameExtractor(DirectFrameExtractor):
                          unit_chunker=SentenceUnitChunker(),
                          prompt_template=prompt_template, 
                          system_prompt=system_prompt, 
-                         context_chunker=context_chunker,
-                         **kwrs)
+                         context_chunker=context_chunker)
         
 
 class SentenceReviewFrameExtractor(ReviewFrameExtractor):
     def __init__(self, inference_engine:InferenceEngine, prompt_template:str,  
                  review_mode:str, review_prompt:str=None, system_prompt:str=None,
-                 context_sentences:Union[str, int]="all", **kwrs):
+                 context_sentences:Union[str, int]="all"):
         """
         This class adds a review step after the SentenceFrameExtractor.
         For each sentence, the review process asks LLM to review its output and:
@@ -1561,15 +1446,14 @@ class SentenceReviewFrameExtractor(ReviewFrameExtractor):
                          review_mode=review_mode,
                          review_prompt=review_prompt, 
                          system_prompt=system_prompt, 
-                         context_chunker=context_chunker,
-                         **kwrs)
+                         context_chunker=context_chunker)
     
 
-class RelationExtractor(Extractor):
-    def __init__(self, inference_engine:InferenceEngine, prompt_template:str, system_prompt:str=None, **kwrs):
+class AttributeExtractor(Extractor):
+    def __init__(self, inference_engine:InferenceEngine, prompt_template:str, system_prompt:str=None):
         """
-        This is the abstract class for relation extraction.
-        Input LLM inference engine, system prompt (optional), prompt template (with instruction, few-shot examples).
+        This class is for attribute extraction for frames. Though FrameExtractors can also extract attributes, when
+        the number of attribute increases, it is more efficient to use a dedicated AttributeExtractor.
 
         Parameters
         ----------
@@ -1582,350 +1466,475 @@ class RelationExtractor(Extractor):
         """
         super().__init__(inference_engine=inference_engine,
                          prompt_template=prompt_template,
-                         system_prompt=system_prompt,
-                         **kwrs)
+                         system_prompt=system_prompt)
+        # validate prompt template
+        if "{{context}}" not in self.prompt_template or "{{frame}}" not in self.prompt_template:
+            raise ValueError("prompt_template must contain both {{context}} and {{frame}} placeholders.")
         
-    def _get_ROI(self, frame_1:LLMInformationExtractionFrame, frame_2:LLMInformationExtractionFrame, 
-                 text:str, buffer_size:int=100) -> str:
+    def _get_context(self, frame:LLMInformationExtractionFrame, text:str, context_size:int=256) -> str:
         """
-        This method returns the Region of Interest (ROI) that covers the two frames. Leaves a buffer_size of characters before and after.
-        The returned text has the two frames inline annotated with <entity_1>, <entity_2>.
+        This method returns the context that covers the frame. Leaves a context_size of characters before and after.
+        The returned text has the frame inline annotated with <entity>.
 
         Parameters:
         -----------
-        frame_1 : LLMInformationExtractionFrame
+        frame : LLMInformationExtractionFrame
             a frame
-        frame_2 : LLMInformationExtractionFrame
-            the other frame
         text : str
             the entire document text
-        buffer_size : int, Optional
-            the number of characters before and after the two frames in the ROI text.
+        context_size : int, Optional
+            the number of characters before and after the frame in the context text.
 
         Return : str
-            the ROI text with the two frames inline annotated with <entity_1>, <entity_2>.
+            the context text with the frame inline annotated with <entity>.
         """
-        left_frame, right_frame = sorted([frame_1, frame_2], key=lambda f: f.start)
-        left_frame_name = "entity_1" if left_frame == frame_1 else "entity_2"
-        right_frame_name = "entity_1" if right_frame == frame_1 else "entity_2"
-
-        start = max(left_frame.start - buffer_size, 0)
-        end = min(right_frame.end + buffer_size, len(text))
-        roi = text[start:end]
+        start = max(frame.start - context_size, 0)
+        end = min(frame.end + context_size, len(text))
+        context = text[start:end]
 
-        roi_annotated = roi[0:left_frame.start - start] + \
-                f'<{left_frame_name}>' + \
-                roi[left_frame.start - start:left_frame.end - start] + \
-                f"</{left_frame_name}>" + \
-                roi[left_frame.end - start:right_frame.start - start] + \
-                f'<{right_frame_name}>' + \
-                roi[right_frame.start - start:right_frame.end - start] + \
-                f"</{right_frame_name}>" + \
-                roi[right_frame.end - start:end - start]
+        context_annotated = context[0:frame.start - start] + \
+                f"<entity> " + \
+                context[frame.start - start:frame.end - start] + \
+                f" </entity>" + \
+                context[frame.end - start:end - start]
 
         if start > 0:
-            roi_annotated = "..." + roi_annotated
+            context_annotated = "..." + context_annotated
         if end < len(text):
-            roi_annotated = roi_annotated + "..."
-        return roi_annotated
+            context_annotated = context_annotated + "..."
+        return context_annotated
     
-
-    @abc.abstractmethod
-    def extract_relations(self, doc:LLMInformationExtractionDocument, buffer_size:int=100, max_new_tokens:int=128, 
-                         temperature:float=0.0, stream:bool=False, return_messages_log:bool=False, **kwrs) -> List[Dict]:
+    def _extract_from_frame(self, frame:LLMInformationExtractionFrame, text:str,
+                            context_size:int=256, verbose:bool=False, return_messages_log:bool=False) -> Dict[str, Any]:
         """
-        This method considers all combinations of two frames. 
+        This method extracts attributes from a single frame.
 
         Parameters:
         -----------
-        doc : LLMInformationExtractionDocument
-            a document with frames.
-        buffer_size : int, Optional
-            the number of characters before and after the two frames in the ROI text.
-        max_new_tokens : str, Optional
-            the max number of new tokens LLM should generate. 
-        temperature : float, Optional
-            the temperature for token sampling.
-        stream : bool, Optional
-            if True, LLM generated text will be printed in terminal in real-time. 
+        frame : LLMInformationExtractionFrame
+            a frame to extract attributes from.
+        text : str
+            the entire document text.
+        context_size : int, Optional
+            the number of characters before and after the frame in the context text.
+        verbose : bool, Optional
+            if True, LLM generated text will be printed in terminal in real-time.
         return_messages_log : bool, Optional
             if True, a list of messages will be returned.
 
-        Return : List[Dict]
-            a list of dict with {"frame_1", "frame_2"} for all relations.
+        Return : Dict[str, Any]
+            a dictionary of attributes extracted from the frame.
+            If return_messages_log is True, a list of messages will be returned as well.
         """
-        return NotImplemented
-    
+        # construct chat messages
+        messages = []
+        if self.system_prompt:
+            messages.append({'role': 'system', 'content': self.system_prompt})
 
-class BinaryRelationExtractor(RelationExtractor):
-    def __init__(self, inference_engine:InferenceEngine, prompt_template:str, possible_relation_func: Callable, 
-                 system_prompt:str=None, **kwrs):
-        """
-        This class extracts binary (yes/no) relations between two entities.
-        Input LLM inference engine, system prompt (optional), prompt template (with instruction, few-shot examples).
+        context = self._get_context(frame, text, context_size)
+        messages.append({'role': 'user', 'content': self._get_user_prompt({"context": context, "frame": str(frame.to_dict())})})
 
-        Parameters
-        ----------
-        inference_engine : InferenceEngine
-            the LLM inferencing engine object. Must implements the chat() method.
-        prompt_template : str
-            prompt template with "{{<placeholder name>}}" placeholder.
-        possible_relation_func : Callable, Optional
-            a function that inputs 2 frames and returns a bool indicating possible relations between them.
-        system_prompt : str, Optional
-            system prompt.
-        """
-        super().__init__(inference_engine=inference_engine,
-                         prompt_template=prompt_template,
-                         system_prompt=system_prompt,
-                         **kwrs)
-        
-        if possible_relation_func:
-            # Check if possible_relation_func is a function
-            if not callable(possible_relation_func):
-                raise TypeError(f"Expect possible_relation_func as a function, received {type(possible_relation_func)} instead.")
+        if verbose:
+            print(f"\n\n{Fore.GREEN}Frame: {frame.frame_id}{Style.RESET_ALL}\n{frame.to_dict()}\n")
+            if context != "":
+                print(f"{Fore.YELLOW}Context:{Style.RESET_ALL}\n{context}\n")
             
-            sig = inspect.signature(possible_relation_func)
-            # Check if frame_1, frame_2 are in input parameters
-            if len(sig.parameters) != 2:
-                raise ValueError("The possible_relation_func must have exactly frame_1 and frame_2 as parameters.")
-            if "frame_1" not in sig.parameters.keys():
-                raise ValueError("The possible_relation_func is missing frame_1 as a parameter.")
-            if "frame_2" not in sig.parameters.keys():
-                raise ValueError("The possible_relation_func is missing frame_2 as a parameter.")
-            # Check if output is a bool
-            if sig.return_annotation != bool:
-                raise ValueError(f"Expect possible_relation_func to output a bool, current type hint suggests {sig.return_annotation} instead.")
-
-            self.possible_relation_func = possible_relation_func
-
-
-    def _post_process(self, rel_json:str) -> bool:
-        if len(rel_json) > 0:
-            if "Relation" in rel_json[0]:
-                rel = rel_json[0]["Relation"]
-                if isinstance(rel, bool):
-                    return rel
-                elif isinstance(rel, str) and rel in {"True", "False"}:
-                    return eval(rel)
-                else:
-                    warnings.warn('Extractor output JSON "Relation" key does not have bool or {"True", "False"} as value.' + \
-                                'Following default, relation = False.', RuntimeWarning)
-            else:
-                warnings.warn('Extractor output JSON without "Relation" key. Following default, relation = False.', RuntimeWarning)
-        else:
-            warnings.warn('Extractor did not output a JSON list. Following default, relation = False.', RuntimeWarning)
-        return False
-    
+            print(f"{Fore.BLUE}Extraction:{Style.RESET_ALL}")
 
-    def extract(self, doc:LLMInformationExtractionDocument, buffer_size:int=100, max_new_tokens:int=128, 
-                temperature:float=0.0, stream:bool=False, return_messages_log:bool=False, **kwrs) -> List[Dict]:
+        get_text = self.inference_engine.chat(
+                            messages=messages,
+                            verbose=verbose,
+                            stream=False
+                        )
+        if return_messages_log:
+            messages.append({"role": "assistant", "content": get_text})
+
+        attribute_list = self._extract_json(gen_text=get_text)
+        if isinstance(attribute_list, list) and len(attribute_list) > 0:
+            attributes = attribute_list[0]
+            if return_messages_log:
+                return attributes, messages
+            return attributes
+
+
+    def extract(self, frames:List[LLMInformationExtractionFrame], text:str, context_size:int=256, verbose:bool=False, 
+                return_messages_log:bool=False, inplace:bool=True) -> Union[None, List[LLMInformationExtractionFrame]]:
         """
-        This method considers all combinations of two frames. Use the possible_relation_func to filter impossible pairs.
-        Outputs pairs that are related.
+        This method extracts attributes from the document.
 
         Parameters:
         -----------
-        doc : LLMInformationExtractionDocument
-            a document with frames.
-        buffer_size : int, Optional
-            the number of characters before and after the two frames in the ROI text.
-        max_new_tokens : str, Optional
-            the max number of new tokens LLM should generate. 
-        temperature : float, Optional
-            the temperature for token sampling.
-        stream : bool, Optional
+        frames : List[LLMInformationExtractionFrame]
+            a list of frames to extract attributes from.
+        text : str
+            the entire document text.
+        context_size : int, Optional
+            the number of characters before and after the frame in the context text.
+        verbose : bool, Optional
             if True, LLM generated text will be printed in terminal in real-time. 
         return_messages_log : bool, Optional
             if True, a list of messages will be returned.
+        inplace : bool, Optional
+            if True, the method will modify the frames in-place.
+        
+        Return : Union[None, List[LLMInformationExtractionFrame]]
+            if inplace is True, the method will modify the frames in-place.
+            if inplace is False, the method will return a list of frames with attributes extracted.
+        """
+        for frame in frames:
+            if not isinstance(frame, LLMInformationExtractionFrame):
+                raise TypeError(f"Expect frame as LLMInformationExtractionFrame, received {type(frame)} instead.")
+        if not isinstance(text, str):
+            raise TypeError(f"Expect text as str, received {type(text)} instead.")
+        
+        new_frames = []
+        messages_log = [] if return_messages_log else None
 
-        Return : List[Dict]
-            a list of dict with {"frame_1_id", "frame_2_id"}.
-        """
-        pairs = itertools.combinations(doc.frames, 2)
+        for frame in frames:
+            if return_messages_log:
+                attr, messages = self._extract_from_frame(frame=frame, text=text, context_size=context_size,
+                                                          verbose=verbose, return_messages_log=return_messages_log)
+                messages_log.append(messages)
+            else: 
+                attr = self._extract_from_frame(frame=frame, text=text, context_size=context_size,
+                                                verbose=verbose, return_messages_log=return_messages_log)
+            
+            if inplace:
+                frame.attr.update(attr)
+            else:
+                new_frame = frame.copy()
+                new_frame.attr.update(attr)
+                new_frames.append(new_frame)
 
-        if return_messages_log:
-            messages_log = []
+        if inplace:
+            return messages_log if return_messages_log else None
+        else:
+            return (new_frames, messages_log) if return_messages_log else new_frames
 
-        output = []
-        for frame_1, frame_2 in pairs:
-            pos_rel = self.possible_relation_func(frame_1, frame_2)
 
-            if pos_rel:
-                roi_text = self._get_ROI(frame_1, frame_2, doc.text, buffer_size=buffer_size)
-                if stream:
-                    print(f"\n\n{Fore.GREEN}ROI text:{Style.RESET_ALL} \n{roi_text}\n")
-                    print(f"{Fore.BLUE}Extraction:{Style.RESET_ALL}")
+    async def extract_async(self, frames:List[LLMInformationExtractionFrame], text:str, context_size:int=256,
+                            concurrent_batch_size:int=32, inplace:bool=True, return_messages_log:bool=False) -> Union[None, List[LLMInformationExtractionFrame]]:
+        """
+        This method extracts attributes from the document asynchronously.
+
+        Parameters:
+        -----------
+        frames : List[LLMInformationExtractionFrame]
+            a list of frames to extract attributes from.
+        text : str
+            the entire document text.
+        context_size : int, Optional
+            the number of characters before and after the frame in the context text.
+        concurrent_batch_size : int, Optional
+            the batch size for concurrent processing. 
+        inplace : bool, Optional
+            if True, the method will modify the frames in-place.
+        return_messages_log : bool, Optional
+            if True, a list of messages will be returned.
+        
+        Return : Union[None, List[LLMInformationExtractionFrame]]
+            if inplace is True, the method will modify the frames in-place.
+            if inplace is False, the method will return a list of frames with attributes extracted.
+        """
+        # validation
+        for frame in frames:
+            if not isinstance(frame, LLMInformationExtractionFrame):
+                raise TypeError(f"Expect frame as LLMInformationExtractionFrame, received {type(frame)} instead.")
+        if not isinstance(text, str):
+            raise TypeError(f"Expect text as str, received {type(text)} instead.")
+
+        # async helper
+        semaphore = asyncio.Semaphore(concurrent_batch_size)
+        
+        async def semaphore_helper(frame:LLMInformationExtractionFrame, text:str, context_size:int) -> dict:
+            async with semaphore:
                 messages = []
                 if self.system_prompt:
                     messages.append({'role': 'system', 'content': self.system_prompt})
 
-                messages.append({'role': 'user', 'content': self._get_user_prompt(text_content={"roi_text":roi_text, 
-                                                                                                "frame_1": str(frame_1.to_dict()),
-                                                                                                "frame_2": str(frame_2.to_dict())}
-                                                                                                )})
-
-                gen_text = self.inference_engine.chat(
-                                messages=messages, 
-                                max_new_tokens=max_new_tokens, 
-                                temperature=temperature,
-                                stream=stream,
-                                **kwrs
-                            )
-                rel_json = self._extract_json(gen_text)
-                if self._post_process(rel_json):
-                    output.append({'frame_1_id':frame_1.frame_id, 'frame_2_id':frame_2.frame_id})
+                context = self._get_context(frame, text, context_size)
+                messages.append({'role': 'user', 'content': self._get_user_prompt({"context": context, "frame": str(frame.to_dict())})})
 
+                gen_text = await self.inference_engine.chat_async(messages=messages)
+                
                 if return_messages_log:
                     messages.append({"role": "assistant", "content": gen_text})
-                    messages_log.append(messages)
 
-        if return_messages_log:
-            return output, messages_log
-        return output
-    
-    
-    async def extract_async(self, doc:LLMInformationExtractionDocument, buffer_size:int=100, max_new_tokens:int=128, 
-                            temperature:float=0.0, concurrent_batch_size:int=32, return_messages_log:bool=False, **kwrs) -> List[Dict]:
+                attribute_list = self._extract_json(gen_text=gen_text)
+                attributes = attribute_list[0] if isinstance(attribute_list, list) and len(attribute_list) > 0 else {}
+                return {"frame": frame, "attributes": attributes, "messages": messages}
+
+        # create tasks
+        tasks = [asyncio.create_task(semaphore_helper(frame, text, context_size)) for frame in frames]
+        results = await asyncio.gather(*tasks)
+
+        # process results
+        new_frames = []
+        messages_log = [] if return_messages_log else None
+
+        for result in results:
+            if return_messages_log:
+                messages_log.append(result["messages"])
+
+            if inplace:
+                result["frame"].attr.update(result["attributes"])
+            else:
+                new_frame = result["frame"].copy()
+                new_frame.attr.update(result["attributes"])
+                new_frames.append(new_frame)
+
+        # output
+        if inplace:
+            return messages_log if return_messages_log else None
+        else:
+            return (new_frames, messages_log) if return_messages_log else new_frames
+
+    def extract_attributes(self, frames:List[LLMInformationExtractionFrame], text:str, context_size:int=256, 
+                           concurrent:bool=False, concurrent_batch_size:int=32, verbose:bool=False, 
+                           return_messages_log:bool=False, inplace:bool=True) -> Union[None, List[LLMInformationExtractionFrame]]:
         """
-        This is the asynchronous version of the extract() method.
+        This method extracts attributes from the document.
 
         Parameters:
         -----------
-        doc : LLMInformationExtractionDocument
-            a document with frames.
-        buffer_size : int, Optional
-            the number of characters before and after the two frames in the ROI text.
-        max_new_tokens : str, Optional
-            the max number of new tokens LLM should generate. 
-        temperature : float, Optional
-            the temperature for token sampling.
+        frames : List[LLMInformationExtractionFrame]
+            a list of frames to extract attributes from.
+        text : str
+            the entire document text.
+        context_size : int, Optional
+            the number of characters before and after the frame in the context text.
+        concurrent : bool, Optional
+            if True, the method will run in concurrent mode with batch size concurrent_batch_size.
         concurrent_batch_size : int, Optional
-            the number of frame pairs to process in concurrent.
+            the batch size for concurrent processing.
+        verbose : bool, Optional
+            if True, LLM generated text will be printed in terminal in real-time. 
         return_messages_log : bool, Optional
             if True, a list of messages will be returned.
-
-        Return : List[Dict]
-            a list of dict with {"frame_1", "frame_2"}. 
-        """
-        # Check if self.inference_engine.chat_async() is implemented
-        if not hasattr(self.inference_engine, 'chat_async'):
-            raise NotImplementedError(f"{self.inference_engine.__class__.__name__} does not have chat_async() method.")
+        inplace : bool, Optional
+            if True, the method will modify the frames in-place.
         
-        pairs = itertools.combinations(doc.frames, 2)
-        if return_messages_log:
-            messages_log = []
-
-        n_frames = len(doc.frames)
-        num_pairs = (n_frames * (n_frames-1)) // 2
-        output = []
-        for i in range(0, num_pairs, concurrent_batch_size):
-            rel_pair_list = []
-            tasks = []
-            batch = list(itertools.islice(pairs, concurrent_batch_size))
-            batch_messages = []
-            for frame_1, frame_2 in batch:
-                pos_rel = self.possible_relation_func(frame_1, frame_2)
-    
-                if pos_rel:
-                    rel_pair_list.append({'frame_1_id':frame_1.frame_id, 'frame_2_id':frame_2.frame_id})
-                    roi_text = self._get_ROI(frame_1, frame_2, doc.text, buffer_size=buffer_size)
-                    messages = []
-                    if self.system_prompt:
-                        messages.append({'role': 'system', 'content': self.system_prompt})
-
-                    messages.append({'role': 'user', 'content': self._get_user_prompt(text_content={"roi_text":roi_text, 
-                                                                                                    "frame_1": str(frame_1.to_dict()),
-                                                                                                    "frame_2": str(frame_2.to_dict())}
-                                                                                                    )})
-
-                    task = asyncio.create_task(
-                        self.inference_engine.chat_async(
-                            messages=messages, 
-                            max_new_tokens=max_new_tokens, 
-                            temperature=temperature,
-                            **kwrs
-                        )
-                    )
-                    tasks.append(task)
-                    batch_messages.append(messages)
+        Return : Union[None, List[LLMInformationExtractionFrame]]
+            if inplace is True, the method will modify the frames in-place.
+            if inplace is False, the method will return a list of frames with attributes extracted.
+        """
+        if concurrent:
+            if verbose:
+                warnings.warn("verbose=True is not supported in concurrent mode.", RuntimeWarning)
 
-            responses = await asyncio.gather(*tasks)
+            nest_asyncio.apply() # For Jupyter notebook. Terminal does not need this.
 
-            for d, response, messages in zip(rel_pair_list, responses, batch_messages):
-                if return_messages_log:
-                    messages.append({"role": "assistant", "content": response})
-                    messages_log.append(messages)
+            return asyncio.run(self.extract_async(frames=frames, text=text, context_size=context_size,
+                                                  concurrent_batch_size=concurrent_batch_size, 
+                                                  inplace=inplace, return_messages_log=return_messages_log))
+        else:
+            return self.extract(frames=frames, text=text, context_size=context_size, 
+                                verbose=verbose, return_messages_log=return_messages_log, inplace=inplace)
 
-                rel_json = self._extract_json(response)
-                if self._post_process(rel_json):
-                    output.append(d)
-
-        if return_messages_log:
-            return output, messages_log
-        return output
 
+class RelationExtractor(Extractor):
+    def __init__(self, inference_engine:InferenceEngine, prompt_template:str, system_prompt:str=None):
+        """
+        This is the abstract class for relation extraction.
+        Input LLM inference engine, system prompt (optional), prompt template (with instruction, few-shot examples).
 
-    def extract_relations(self, doc:LLMInformationExtractionDocument, buffer_size:int=100, max_new_tokens:int=128, 
-                         temperature:float=0.0, concurrent:bool=False, concurrent_batch_size:int=32, 
-                         stream:bool=False, return_messages_log:bool=False, **kwrs) -> List[Dict]:
+        Parameters
+        ----------
+        inference_engine : InferenceEngine
+            the LLM inferencing engine object. Must implements the chat() method.
+        prompt_template : str
+            prompt template with "{{<placeholder name>}}" placeholder.
+        system_prompt : str, Optional
+            system prompt.
         """
-        This method considers all combinations of two frames. Use the possible_relation_func to filter impossible pairs.
+        super().__init__(inference_engine=inference_engine,
+                         prompt_template=prompt_template,
+                         system_prompt=system_prompt)
+        
+    def _get_ROI(self, frame_1:LLMInformationExtractionFrame, frame_2:LLMInformationExtractionFrame, 
+                 text:str, buffer_size:int=128) -> str:
+        """
+        This method returns the Region of Interest (ROI) that covers the two frames. Leaves a buffer_size of characters before and after.
+        The returned text has the two frames inline annotated with <entity_1>, <entity_2>.
 
         Parameters:
         -----------
-        doc : LLMInformationExtractionDocument
-            a document with frames.
+        frame_1 : LLMInformationExtractionFrame
+            a frame
+        frame_2 : LLMInformationExtractionFrame
+            the other frame
+        text : str
+            the entire document text
         buffer_size : int, Optional
             the number of characters before and after the two frames in the ROI text.
-        max_new_tokens : str, Optional
-            the max number of new tokens LLM should generate. 
-        temperature : float, Optional
-            the temperature for token sampling.
-        concurrent: bool, Optional
-            if True, the extraction will be done in concurrent.
-        concurrent_batch_size : int, Optional
-            the number of frame pairs to process in concurrent.
-        stream : bool, Optional
-            if True, LLM generated text will be printed in terminal in real-time. 
-        return_messages_log : bool, Optional
-            if True, a list of messages will be returned.
 
-        Return : List[Dict]
-            a list of dict with {"frame_1", "frame_2"} for all relations.
+        Return : str
+            the ROI text with the two frames inline annotated with <entity_1>, <entity_2>.
         """
+        left_frame, right_frame = sorted([frame_1, frame_2], key=lambda f: f.start)
+        left_frame_name = "entity_1" if left_frame.frame_id == frame_1.frame_id else "entity_2"
+        right_frame_name = "entity_1" if right_frame.frame_id == frame_1.frame_id else "entity_2"
+
+        start = max(left_frame.start - buffer_size, 0)
+        end = min(right_frame.end + buffer_size, len(text))
+        roi = text[start:end]
+
+        roi_annotated = roi[0:left_frame.start - start] + \
+                f"<{left_frame_name}> " + \
+                roi[left_frame.start - start:left_frame.end - start] + \
+                f" </{left_frame_name}>" + \
+                roi[left_frame.end - start:right_frame.start - start] + \
+                f"<{right_frame_name}> " + \
+                roi[right_frame.start - start:right_frame.end - start] + \
+                f" </{right_frame_name}>" + \
+                roi[right_frame.end - start:end - start]
+
+        if start > 0:
+            roi_annotated = "..." + roi_annotated
+        if end < len(text):
+            roi_annotated = roi_annotated + "..."
+        return roi_annotated
+    
+    @abc.abstractmethod
+    def _get_task_if_possible(self, frame_1: LLMInformationExtractionFrame, frame_2: LLMInformationExtractionFrame, 
+                              text: str, buffer_size: int) -> Optional[Dict[str, Any]]:
+        """Checks if a relation is possible and constructs the task payload."""
+        raise NotImplementedError
+
+    @abc.abstractmethod
+    def _post_process_result(self, gen_text: str, pair_data: Dict[str, Any]) -> Optional[Dict[str, Any]]:
+        """Processes the LLM output for a single pair and returns the final relation dictionary."""
+        raise NotImplementedError
+
+    def _extract(self, doc: LLMInformationExtractionDocument, buffer_size: int = 128, verbose: bool = False, 
+                 return_messages_log: bool = False) -> Union[List[Dict], Tuple[List[Dict], List]]:
+        pairs = itertools.combinations(doc.frames, 2)
+        relations = []
+        messages_log = [] if return_messages_log else None
+
+        for frame_1, frame_2 in pairs:
+            task_payload = self._get_task_if_possible(frame_1, frame_2, doc.text, buffer_size)
+            if task_payload:
+                if verbose:
+                    print(f"\n\n{Fore.GREEN}Evaluating pair:{Style.RESET_ALL} ({frame_1.frame_id}, {frame_2.frame_id})")
+                    print(f"{Fore.YELLOW}ROI Text:{Style.RESET_ALL}\n{task_payload['roi_text']}\n")
+                    print(f"{Fore.BLUE}Extraction:{Style.RESET_ALL}")
+
+                gen_text = self.inference_engine.chat(
+                    messages=task_payload['messages'],
+                    verbose=verbose
+                )
+                relation = self._post_process_result(gen_text, task_payload)
+                if relation:
+                    relations.append(relation)
+
+                if return_messages_log:
+                    task_payload['messages'].append({"role": "assistant", "content": gen_text})
+                    messages_log.append(task_payload['messages'])
+
+        return (relations, messages_log) if return_messages_log else relations
+
+    async def _extract_async(self, doc: LLMInformationExtractionDocument, buffer_size: int = 128, concurrent_batch_size: int = 32, return_messages_log: bool = False) -> Union[List[Dict], Tuple[List[Dict], List]]:
+        pairs = list(itertools.combinations(doc.frames, 2))
+        tasks_input = [self._get_task_if_possible(f1, f2, doc.text, buffer_size) for f1, f2 in pairs]
+        # Filter out impossible pairs
+        tasks_input = [task for task in tasks_input if task is not None] 
+
+        relations = []
+        messages_log = [] if return_messages_log else None
+        semaphore = asyncio.Semaphore(concurrent_batch_size)
+
+        async def semaphore_helper(task_payload: Dict):
+            async with semaphore:
+                gen_text = await self.inference_engine.chat_async(messages=task_payload['messages'])
+                return gen_text, task_payload
+
+        tasks = [asyncio.create_task(semaphore_helper(payload)) for payload in tasks_input]
+        results = await asyncio.gather(*tasks)
+
+        for gen_text, task_payload in results:
+            relation = self._post_process_result(gen_text, task_payload)
+            if relation:
+                relations.append(relation)
+
+            if return_messages_log:
+                task_payload['messages'].append({"role": "assistant", "content": gen_text})
+                messages_log.append(task_payload['messages'])
+
+        return (relations, messages_log) if return_messages_log else relations
+
+    def extract_relations(self, doc: LLMInformationExtractionDocument, buffer_size: int = 128, concurrent: bool = False, concurrent_batch_size: int = 32, verbose: bool = False, return_messages_log: bool = False) -> List[Dict]:
         if not doc.has_frame():
             raise ValueError("Input document must have frames.")
-
         if doc.has_duplicate_frame_ids():
             raise ValueError("All frame_ids in the input document must be unique.")
 
         if concurrent:
-            if stream:
-                warnings.warn("stream=True is not supported in concurrent mode.", RuntimeWarning)
-
-            nest_asyncio.apply() # For Jupyter notebook. Terminal does not need this.
-            return asyncio.run(self.extract_async(doc=doc, 
-                                                  buffer_size=buffer_size, 
-                                                  max_new_tokens=max_new_tokens,
-                                                  temperature=temperature,
-                                                  concurrent_batch_size=concurrent_batch_size, 
-                                                  return_messages_log=return_messages_log,
-                                                  **kwrs)
-                                )
+            if verbose:
+                warnings.warn("verbose=True is not supported in concurrent mode.", RuntimeWarning)
+            nest_asyncio.apply()
+            return asyncio.run(self._extract_async(doc, buffer_size, concurrent_batch_size, return_messages_log))
         else:
-            return self.extract(doc=doc, 
-                                buffer_size=buffer_size, 
-                                max_new_tokens=max_new_tokens,
-                                temperature=temperature,
-                                stream=stream,
-                                return_messages_log=return_messages_log,
-                                **kwrs)
+            return self._extract(doc, buffer_size, verbose, return_messages_log)
+    
+
+class BinaryRelationExtractor(RelationExtractor):
+    def __init__(self, inference_engine:InferenceEngine, prompt_template:str, possible_relation_func: Callable,
+                 system_prompt:str=None):
+        """
+        This class extracts binary (yes/no) relations between two entities.
+        Input LLM inference engine, system prompt (optional), prompt template (with instruction, few-shot examples).
+
+        Parameters
+        ----------
+        inference_engine : InferenceEngine
+            the LLM inferencing engine object. Must implements the chat() method.
+        prompt_template : str
+            prompt template with "{{<placeholder name>}}" placeholder.
+        possible_relation_func : Callable, Optional
+            a function that inputs 2 frames and returns a bool indicating possible relations between them.
+        system_prompt : str, Optional
+            system prompt.
+        """
+        super().__init__(inference_engine, prompt_template, system_prompt)
+        if not callable(possible_relation_func):
+            raise TypeError(f"Expect possible_relation_func as a function, received {type(possible_relation_func)} instead.")
+        
+        sig = inspect.signature(possible_relation_func)
+        if len(sig.parameters) != 2:
+            raise ValueError("The possible_relation_func must have exactly two parameters.")
+        
+        if sig.return_annotation not in {bool, inspect.Signature.empty}:
+            warnings.warn(f"Expected possible_relation_func return annotation to be bool, but got {sig.return_annotation}.")
+        
+        self.possible_relation_func = possible_relation_func
+
+    def _get_task_if_possible(self, frame_1: LLMInformationExtractionFrame, frame_2: LLMInformationExtractionFrame, 
+                              text: str, buffer_size: int) -> Optional[Dict[str, Any]]:
+        if self.possible_relation_func(frame_1, frame_2):
+            roi_text = self._get_ROI(frame_1, frame_2, text, buffer_size)
+            messages = []
+            if self.system_prompt:
+                messages.append({'role': 'system', 'content': self.system_prompt})
+
+            messages.append({'role': 'user', 'content': self._get_user_prompt(
+                text_content={"roi_text": roi_text, "frame_1": str(frame_1.to_dict()), "frame_2": str(frame_2.to_dict())}
+            )})
+            return {"frame_1": frame_1, "frame_2": frame_2, "messages": messages, "roi_text": roi_text}
+        return None
+
+    def _post_process_result(self, gen_text: str, pair_data: Dict[str, Any]) -> Optional[Dict[str, Any]]:
+        rel_json = self._extract_json(gen_text)
+        if len(rel_json) > 0 and "Relation" in rel_json[0]:
+            rel = rel_json[0]["Relation"]
+            if (isinstance(rel, bool) and rel) or (isinstance(rel, str) and rel.lower() == 'true'):
+                return {'frame_1_id': pair_data['frame_1'].frame_id, 'frame_2_id': pair_data['frame_2'].frame_id}
+        return None
             
 
 class MultiClassRelationExtractor(RelationExtractor):
     def __init__(self, inference_engine:InferenceEngine, prompt_template:str, possible_relation_types_func: Callable, 
-                 system_prompt:str=None, **kwrs):
+                 system_prompt:str=None):
         """
         This class extracts relations with relation types.
         Input LLM inference engine, system prompt (optional), prompt template (with instruction, few-shot examples).
@@ -1944,8 +1953,7 @@ class MultiClassRelationExtractor(RelationExtractor):
         """
         super().__init__(inference_engine=inference_engine,
                          prompt_template=prompt_template,
-                         system_prompt=system_prompt,
-                         **kwrs)
+                         system_prompt=system_prompt)
         
         if possible_relation_types_func:
             # Check if possible_relation_types_func is a function
@@ -1967,235 +1975,25 @@ class MultiClassRelationExtractor(RelationExtractor):
             self.possible_relation_types_func = possible_relation_types_func
 
 
-    def _post_process(self, rel_json:List[Dict], pos_rel_types:List[str]) -> Union[str, None]:
-        """
-        This method post-processes the extracted relation JSON.
-
-        Parameters:
-        -----------
-        rel_json : List[Dict]
-            the extracted relation JSON.
-        pos_rel_types : List[str]
-            possible relation types by the possible_relation_types_func.
-
-        Return : Union[str, None]
-            the relation type (str) or None for no relation.
-        """
-        if len(rel_json) > 0:
-            if "RelationType" in rel_json[0]:
-                if rel_json[0]["RelationType"] in pos_rel_types:
-                    return rel_json[0]["RelationType"]
-            else:
-                warnings.warn('Extractor output JSON without "RelationType" key. Following default, relation = "No Relation".', RuntimeWarning)
-        else:
-            warnings.warn('Extractor did not output a JSON. Following default, relation = "No Relation".', RuntimeWarning)
+    def _get_task_if_possible(self, frame_1: LLMInformationExtractionFrame, frame_2: LLMInformationExtractionFrame, 
+                              text: str, buffer_size: int) -> Optional[Dict[str, Any]]:
+        pos_rel_types = self.possible_relation_types_func(frame_1, frame_2)
+        if pos_rel_types:
+            roi_text = self._get_ROI(frame_1, frame_2, text, buffer_size)
+            messages = []
+            if self.system_prompt:
+                messages.append({'role': 'system', 'content': self.system_prompt})
+            messages.append({'role': 'user', 'content': self._get_user_prompt(
+                text_content={"roi_text": roi_text, "frame_1": str(frame_1.to_dict()), "frame_2": str(frame_2.to_dict()), "pos_rel_types": str(pos_rel_types)}
+            )})
+            return {"frame_1": frame_1, "frame_2": frame_2, "messages": messages, "pos_rel_types": pos_rel_types, "roi_text": roi_text}
         return None
-    
-
-    def extract(self, doc:LLMInformationExtractionDocument, buffer_size:int=100, max_new_tokens:int=128, 
-                temperature:float=0.0, stream:bool=False, return_messages_log:bool=False, **kwrs) -> List[Dict]:
-        """
-        This method considers all combinations of two frames. Use the possible_relation_types_func to filter impossible pairs.
-
-        Parameters:
-        -----------
-        doc : LLMInformationExtractionDocument
-            a document with frames.
-        buffer_size : int, Optional
-            the number of characters before and after the two frames in the ROI text.
-        max_new_tokens : str, Optional
-            the max number of new tokens LLM should generate. 
-        temperature : float, Optional
-            the temperature for token sampling.
-        stream : bool, Optional
-            if True, LLM generated text will be printed in terminal in real-time. 
-        return_messages_log : bool, Optional
-            if True, a list of messages will be returned.
-
-        Return : List[Dict]
-            a list of dict with {"frame_1_id", "frame_2_id", "relation"} for all frame pairs.
-        """
-        pairs = itertools.combinations(doc.frames, 2)
-
-        if return_messages_log:
-            messages_log = []
-
-        output = []
-        for frame_1, frame_2 in pairs:
-            pos_rel_types = self.possible_relation_types_func(frame_1, frame_2)
-
-            if pos_rel_types:
-                roi_text = self._get_ROI(frame_1, frame_2, doc.text, buffer_size=buffer_size)
-                if stream:
-                    print(f"\n\n{Fore.GREEN}ROI text:{Style.RESET_ALL} \n{roi_text}\n")
-                    print(f"{Fore.BLUE}Extraction:{Style.RESET_ALL}")
-                messages = []
-                if self.system_prompt:
-                    messages.append({'role': 'system', 'content': self.system_prompt})
-
-                messages.append({'role': 'user', 'content': self._get_user_prompt(text_content={"roi_text":roi_text, 
-                                                                                                "frame_1": str(frame_1.to_dict()),
-                                                                                                "frame_2": str(frame_2.to_dict()),
-                                                                                                "pos_rel_types":str(pos_rel_types)}
-                                                                                                )})
-
-                gen_text = self.inference_engine.chat(
-                                messages=messages, 
-                                max_new_tokens=max_new_tokens, 
-                                temperature=temperature,
-                                stream=stream,
-                                **kwrs
-                            )
-                
-                if return_messages_log:
-                    messages.append({"role": "assistant", "content": gen_text})
-                    messages_log.append(messages)
-
-                rel_json = self._extract_json(gen_text)
-                rel = self._post_process(rel_json, pos_rel_types)
-                if rel:
-                    output.append({'frame_1_id':frame_1.frame_id, 'frame_2_id':frame_2.frame_id, 'relation':rel})
-
-        if return_messages_log:
-            return output, messages_log
-        return output   
-    
-    
-    async def extract_async(self, doc:LLMInformationExtractionDocument, buffer_size:int=100, max_new_tokens:int=128, 
-                            temperature:float=0.0, concurrent_batch_size:int=32, return_messages_log:bool=False, **kwrs) -> List[Dict]:
-        """
-        This is the asynchronous version of the extract() method.
-
-        Parameters:
-        -----------
-        doc : LLMInformationExtractionDocument
-            a document with frames.
-        buffer_size : int, Optional
-            the number of characters before and after the two frames in the ROI text.
-        max_new_tokens : str, Optional
-            the max number of new tokens LLM should generate. 
-        temperature : float, Optional
-            the temperature for token sampling.
-        concurrent_batch_size : int, Optional
-            the number of frame pairs to process in concurrent.
-        return_messages_log : bool, Optional
-            if True, a list of messages will be returned.
-
-        Return : List[Dict]
-            a list of dict with {"frame_1_id", "frame_2_id", "relation"} for all frame pairs. 
-        """
-        # Check if self.inference_engine.chat_async() is implemented
-        if not hasattr(self.inference_engine, 'chat_async'):
-            raise NotImplementedError(f"{self.inference_engine.__class__.__name__} does not have chat_async() method.")
-        
-        pairs = itertools.combinations(doc.frames, 2)
-        if return_messages_log:
-            messages_log = []
-
-        n_frames = len(doc.frames)
-        num_pairs = (n_frames * (n_frames-1)) // 2
-        output = []
-        for i in range(0, num_pairs, concurrent_batch_size):
-            rel_pair_list = []
-            tasks = []
-            batch = list(itertools.islice(pairs, concurrent_batch_size))
-            batch_messages = []
-            for frame_1, frame_2 in batch:
-                pos_rel_types = self.possible_relation_types_func(frame_1, frame_2)
-    
-                if pos_rel_types:
-                    rel_pair_list.append({'frame_1':frame_1.frame_id, 'frame_2':frame_2.frame_id, 'pos_rel_types':pos_rel_types})
-                    roi_text = self._get_ROI(frame_1, frame_2, doc.text, buffer_size=buffer_size)
-                    messages = []
-                    if self.system_prompt:
-                        messages.append({'role': 'system', 'content': self.system_prompt})
-
-                    messages.append({'role': 'user', 'content': self._get_user_prompt(text_content={"roi_text":roi_text, 
-                                                                                                    "frame_1": str(frame_1.to_dict()),
-                                                                                                    "frame_2": str(frame_2.to_dict()),
-                                                                                                    "pos_rel_types":str(pos_rel_types)}
-                                                                                                    )})
-                    task = asyncio.create_task(
-                        self.inference_engine.chat_async(
-                            messages=messages, 
-                            max_new_tokens=max_new_tokens, 
-                            temperature=temperature,
-                            **kwrs
-                        )
-                    )
-                    tasks.append(task)
-                    batch_messages.append(messages)
-
-            responses = await asyncio.gather(*tasks)
-
-            for d, response, messages in zip(rel_pair_list, responses, batch_messages):
-                if return_messages_log:
-                    messages.append({"role": "assistant", "content": response})
-                    messages_log.append(messages)
-
-                rel_json = self._extract_json(response)
-                rel = self._post_process(rel_json, d['pos_rel_types'])
-                if rel:
-                    output.append({'frame_1_id':d['frame_1'], 'frame_2_id':d['frame_2'], 'relation':rel})
-
-        if return_messages_log:
-            return output, messages_log
-        return output
-
 
-    def extract_relations(self, doc:LLMInformationExtractionDocument, buffer_size:int=100, max_new_tokens:int=128, 
-                         temperature:float=0.0, concurrent:bool=False, concurrent_batch_size:int=32, 
-                         stream:bool=False, return_messages_log:bool=False, **kwrs) -> List[Dict]:
-        """
-        This method considers all combinations of two frames. Use the possible_relation_types_func to filter impossible pairs.
-
-        Parameters:
-        -----------
-        doc : LLMInformationExtractionDocument
-            a document with frames.
-        buffer_size : int, Optional
-            the number of characters before and after the two frames in the ROI text.
-        max_new_tokens : str, Optional
-            the max number of new tokens LLM should generate. 
-        temperature : float, Optional
-            the temperature for token sampling.
-        concurrent: bool, Optional
-            if True, the extraction will be done in concurrent.
-        concurrent_batch_size : int, Optional
-            the number of frame pairs to process in concurrent.
-        stream : bool, Optional
-            if True, LLM generated text will be printed in terminal in real-time. 
-        return_messages_log : bool, Optional
-            if True, a list of messages will be returned.
-
-        Return : List[Dict]
-            a list of dict with {"frame_1", "frame_2", "relation"} for all relations.
-        """
-        if not doc.has_frame():
-            raise ValueError("Input document must have frames.")
-
-        if doc.has_duplicate_frame_ids():
-            raise ValueError("All frame_ids in the input document must be unique.")
-
-        if concurrent:
-            if stream:
-                warnings.warn("stream=True is not supported in concurrent mode.", RuntimeWarning)
-
-            nest_asyncio.apply() # For Jupyter notebook. Terminal does not need this.
-            return asyncio.run(self.extract_async(doc=doc, 
-                                                  buffer_size=buffer_size, 
-                                                  max_new_tokens=max_new_tokens,
-                                                  temperature=temperature,
-                                                  concurrent_batch_size=concurrent_batch_size, 
-                                                  return_messages_log=return_messages_log,
-                                                  **kwrs)
-                                )
-        else:
-            return self.extract(doc=doc, 
-                                buffer_size=buffer_size, 
-                                max_new_tokens=max_new_tokens,
-                                temperature=temperature,
-                                stream=stream,
-                                return_messages_log=return_messages_log,
-                                **kwrs)
-            
+    def _post_process_result(self, gen_text: str, pair_data: Dict[str, Any]) -> Optional[Dict[str, Any]]:
+        rel_json = self._extract_json(gen_text)
+        pos_rel_types = pair_data['pos_rel_types']
+        if len(rel_json) > 0 and "RelationType" in rel_json[0]:
+            rel_type = rel_json[0]["RelationType"]
+            if rel_type in pos_rel_types:
+                return {'frame_1_id': pair_data['frame_1'].frame_id, 'frame_2_id': pair_data['frame_2'].frame_id, 'relation': rel_type}
+        return None