content-core 0.5.0__py3-none-any.whl → 0.6.0__py3-none-any.whl

content_core/processors/audio.py

@@ -1,13 +1,13 @@
 import asyncio
 import os
+import tempfile
+import math
+import traceback
 from functools import partial
-from math import ceil
-
-from pydub import AudioSegment
+from moviepy import AudioFileClip
 
 from content_core.common import ProcessSourceState
 from content_core.logging import logger
-from content_core.models import ModelFactory
 
 # todo: remove reference to model_manager
 # future: parallelize the transcription process
@@ -29,31 +29,29 @@ async def split_audio(input_file, segment_length_minutes=15, output_prefix=None)
             output_prefix = os.path.splitext(os.path.basename(input_file_abs))[0]
 
         # Load the audio file
-        audio = AudioSegment.from_file(input_file_abs)
+        audio = AudioFileClip(input_file_abs)
 
-        # Calculate segment length in milliseconds
-        segment_length_ms = segment_length_minutes * 60 * 1000
+        # Calculate segment length in seconds
+        segment_length_s = segment_length_minutes * 60
 
         # Calculate number of segments
-        total_segments = ceil(len(audio) / segment_length_ms)
+        total_segments = math.ceil(audio.duration / segment_length_s)
         logger.debug(f"Splitting file: {input_file_abs} into {total_segments} segments")
 
         output_files = []
 
         # Split the audio into segments
         for i in range(total_segments):
-            start_time = i * segment_length_ms
-            end_time = min((i + 1) * segment_length_ms, len(audio))
+            start_time = i * segment_length_s
+            end_time = min((i + 1) * segment_length_s, audio.duration)
 
             # Extract segment
-            segment = audio[start_time:end_time]
-
-            # Generate output filename
             output_filename = f"{output_prefix}_{str(i+1).zfill(3)}.mp3"
             output_path = os.path.join(output_dir, output_filename)
 
             # Export segment
-            segment.export(output_path, format="mp3")
+            extract_audio(input_file_abs, output_path, start_time, end_time)
+
             output_files.append(output_path)
 
             logger.debug(f"Exported segment {i+1}/{total_segments}: {output_filename}")
@@ -66,43 +64,87 @@ async def split_audio(input_file, segment_length_minutes=15, output_prefix=None)
     )
 
 
+def extract_audio(input_file: str, output_file: str, start_time: float = None, end_time: float = None) -> None:
+    """
+    Extract audio from a video or audio file and save it as an MP3 file.
+    If start_time and end_time are provided, only that segment of audio is extracted.
+
+    Args:
+        input_file (str): Path to the input video or audio file.
+        output_file (str): Path where the output MP3 file will be saved.
+        start_time (float, optional): Start time of the audio segment in seconds. Defaults to None.
+        end_time (float, optional): End time of the audio segment in seconds. Defaults to None.
+    """
+    try:
+        # Load the file as an AudioFileClip
+        audio_clip = AudioFileClip(input_file)
+        
+        # If start_time and end_time are provided, trim the audio
+        if start_time is not None and end_time is not None:
+            audio_clip = audio_clip.cutout(0, start_time).cutout(end_time - start_time, audio_clip.duration)
+        elif start_time is not None:
+            audio_clip = audio_clip.cutout(0, start_time)
+        elif end_time is not None:
+            audio_clip = audio_clip.cutout(end_time, audio_clip.duration)
+
+        # Export the audio as MP3
+        audio_clip.write_audiofile(output_file, codec='mp3')
+        audio_clip.close()
+    except Exception as e:
+        logger.error(f"Error extracting audio: {str(e)}")
+        raise
+
+
 async def transcribe_audio_segment(audio_file, model):
     """Transcribe a single audio segment asynchronously"""
     return (await model.atranscribe(audio_file)).text
 
 
-async def extract_audio(data: ProcessSourceState):
+async def extract_audio_data(data: ProcessSourceState):
     input_audio_path = data.file_path
-    audio_files = []
 
     try:
-        # Split audio into segments
-        audio_files = await split_audio(input_audio_path)
+        # Create a temporary directory for audio segments
+        temp_dir = tempfile.mkdtemp()
+        output_prefix = os.path.splitext(os.path.basename(input_audio_path))[0]
+        output_dir = temp_dir
+        os.makedirs(output_dir, exist_ok=True)
 
-        # Transcribe all segments concurrently
-        speech_to_text_model = ModelFactory.get_model("speech_to_text")
-        transcribe_tasks = [
-            transcribe_audio_segment(audio_file, speech_to_text_model)
-            for audio_file in audio_files
-        ]
-        transcriptions = await asyncio.gather(*transcribe_tasks)
+        # Split audio into segments if longer than 10 minutes
+        audio = AudioFileClip(input_audio_path)
+        duration_s = audio.duration
+        segment_length_s = 10 * 60  # 10 minutes in seconds
+        output_files = []
+
+        if duration_s > segment_length_s:
+            logger.info(f"Audio is longer than 10 minutes ({duration_s}s), splitting into {math.ceil(duration_s / segment_length_s)} segments")
+            for i in range(math.ceil(duration_s / segment_length_s)):
+                start_time = i * segment_length_s
+                end_time = min((i + 1) * segment_length_s, audio.duration)
 
-        return {"content": " ".join(transcriptions)}
+                # Extract segment
+                output_filename = f"{output_prefix}_{str(i+1).zfill(3)}.mp3"
+                output_path = os.path.join(output_dir, output_filename)
 
+                extract_audio(input_audio_path, output_path, start_time, end_time)
+
+                output_files.append(output_path)
+        else:
+            output_files = [input_audio_path]
+
+        # Transcribe audio files
+        from content_core.models import ModelFactory
+        speech_to_text_model = ModelFactory.get_model("speech_to_text")
+        transcriptions = []
+        for audio_file in output_files:
+            transcription = await transcribe_audio_segment(audio_file, speech_to_text_model)
+            transcriptions.append(transcription)
+
+        return {
+            "metadata": {"audio_files": output_files},
+            "content": " ".join(transcriptions)
+        }
     except Exception as e:
-        logger.error(f"Error transcribing audio: {str(e)}")
-        logger.exception(e)
+        logger.error(f"Error processing audio: {str(e)}")
+        logger.error(traceback.format_exc())
         raise
-
-    finally:
-        # Clean up temporary files
-        def _cleanup(files):
-            for file in files:
-                try:
-                    os.remove(file)
-                except OSError as e:
-                    logger.error(f"Error removing temporary file {file}: {str(e)}")
-
-        await asyncio.get_event_loop().run_in_executor(
-            None, partial(_cleanup, audio_files)
-        )

content_core/templated_message.py

@@ -1,18 +1,18 @@
 from typing import Dict, Optional, Union
 
+from ai_prompter import Prompter
 from esperanto import LanguageModel
 from esperanto.common_types import Message
 from pydantic import BaseModel, Field
 
 from content_core.models import ModelFactory
-from content_core.prompter import Prompter
 
 
 class TemplatedMessageInput(BaseModel):
-    system_prompt_template: Optional[str] = ""
-    system_prompt_text: Optional[str] = ""
-    user_prompt_template: Optional[str] = ""
-    user_prompt_text: Optional[str] = ""
+    system_prompt_template: Optional[str] = None
+    system_prompt_text: Optional[str] = None
+    user_prompt_template: Optional[str] = None
+    user_prompt_text: Optional[str] = None
     data: Optional[Union[Dict, BaseModel]] = Field(default_factory=lambda: {})
     config: Dict = Field(
         description="The config for the LLM",
@@ -28,30 +28,22 @@ async def templated_message(
     input: TemplatedMessageInput, model: Optional[LanguageModel] = None
 ) -> str:
     if not model:
-        model = ModelFactory.get_model('default_model')
+        model = ModelFactory.get_model("default_model")
 
     msgs = []
     if input.system_prompt_template or input.system_prompt_text:
-        msgs.append(
-            Message(
-                role="system",
-                content=Prompter(
-                    prompt_template=input.system_prompt_template,
-                    prompt_text=input.system_prompt_text,
-                ).render(data=input.data),
-            )
-        )
+        system_prompt = Prompter(
+            prompt_template=input.system_prompt_template,
+            template_text=input.system_prompt_text,
+        ).render(data=input.data)
+        msgs.append(Message(role="system", content=system_prompt))
 
     if input.user_prompt_template or input.user_prompt_text:
-        msgs.append(
-            Message(
-                role="user",
-                content=Prompter(
-                    prompt_template=input.user_prompt_template,
-                    prompt_text=input.user_prompt_text,
-                ).render(data=input.data),
-            )
-        )
+        user_prompt = Prompter(
+            prompt_template=input.user_prompt_template,
+            template_text=input.user_prompt_text,
+        ).render(data=input.data)
+        msgs.append(Message(role="user", content=user_prompt))
 
     result = await model.achat_complete(msgs)
     return result.content

{content_core-0.5.0.dist-info → content_core-0.6.0.dist-info}/METADATA

@@ -1,10 +1,11 @@
 Metadata-Version: 2.4
 Name: content-core
-Version: 0.5.0
+Version: 0.6.0
 Summary: Extract what matters from any media source
 Author-email: LUIS NOVO <lfnovo@gmail.com>
 License-File: LICENSE
 Requires-Python: >=3.10
+Requires-Dist: ai-prompter>=0.2.3
 Requires-Dist: aiohttp>=3.11
 Requires-Dist: bs4>=0.0.2
 Requires-Dist: dicttoxml>=1.7.16
@@ -14,10 +15,10 @@ Requires-Dist: jinja2>=3.1.6
 Requires-Dist: langdetect>=1.0.9
 Requires-Dist: langgraph>=0.3.29
 Requires-Dist: loguru>=0.7.3
+Requires-Dist: moviepy>=2.1.2
 Requires-Dist: openai>=1.73.0
 Requires-Dist: openpyxl>=3.1.5
 Requires-Dist: pandas>=2.2.3
-Requires-Dist: pydub>=0.25.1
 Requires-Dist: pymupdf>=1.25.5
 Requires-Dist: python-docx>=1.1.2
 Requires-Dist: python-dotenv>=1.1.0

{content_core-0.5.0.dist-info → content_core-0.6.0.dist-info}/RECORD

@@ -1,12 +1,11 @@
-content_core/__init__.py,sha256=sBCcvRJ-9u5htV5AdptlYPNO0R8NmAex2K1XAkJAoL0,6474
+content_core/__init__.py,sha256=ANKeslNXOGumwrkjqgRik23e5PdGps2C0FSup8_XH2Y,6515
 content_core/cc_config.yaml,sha256=w66fo5ut6TPaU3o4hkjnroqg2hkr8YuOG3BRtI50j1s,701
 content_core/config.py,sha256=-aUsTB6Z3fa_XIWdHNXhMgWkVLWjEW1kfyQXXB_-j54,1632
 content_core/logging.py,sha256=oeRdWKknEolptopxF1IvnEGEc0ZUw45QXYUEZ71GcdY,438
 content_core/models.py,sha256=FBV_tV6cmI0F82WfcA6xHag-YMsxI1dIbDGWG-3Eq_Y,935
 content_core/models_config.yaml,sha256=Yr-GS94ffxnkaWojUfpErUMM7m_MShsYjR6QuDjMzwo,444
-content_core/prompter.py,sha256=-ShuSyHvK50xlgsAFfA9AnAJV-LlzWwmbPDq2wUZRcI,5793
 content_core/py.typed,sha256=pLuU3XTTeVpXo4UomOjcvAIQqOrzIotlWlJ3KFo2lxQ,154
-content_core/templated_message.py,sha256=iWz-TwWq08mspgZW3EgIGf7HqtW1tXuTDpo9FkNwixQ,1729
+content_core/templated_message.py,sha256=KbI2rcvgGM5oRIcsG68zAZfgNsC97fR16D61683ZSnY,1617
 content_core/common/__init__.py,sha256=SjDp-0QRjX9PMubyTjv77_GrUqm6eC4gBuXr593JVK4,525
 content_core/common/exceptions.py,sha256=NpYedVbckIq4kP2wek7bicMVgGGn0fkhCvid5cIxfy4,1304
 content_core/common/state.py,sha256=cJvIwqvrvGxuk1t51bTOvPV-RM5Nbd8F8C4o0dawIXo,1185
@@ -15,12 +14,11 @@ content_core/content/__init__.py,sha256=ymocLXXwWnnhQFHCB3jXanNvJ2m27TVs1yO8EhCr
 content_core/content/cleanup/__init__.py,sha256=wymD24WLDDdsZrv-5WhparSiHBK9SJCcqBHmokuZqk4,121
 content_core/content/cleanup/core.py,sha256=AXUGUWxGob8si5uKRnDrreOcHV_gbGJr4YnRsNm2GX0,531
 content_core/content/extraction/__init__.py,sha256=TaYw6CAcG62GZfsJxeZ6VJDLP85BU2a7_G271v6WWPk,446
-content_core/content/extraction/graph.py,sha256=Sp9XJ6AoLXA_FUFWhmfTMzOC2gkarp1Qg8MsIScLCok,6213
+content_core/content/extraction/graph.py,sha256=d5Hp7GS2dFpYQIHFTIFhU-7ySZ3lfipdDxZZpe2DXS8,6361
 content_core/content/summary/__init__.py,sha256=ReKCZWKfDtqlInKeh87Y1DEfiNzVWabGybEz3hS2FrI,114
 content_core/content/summary/core.py,sha256=LejUbPxnRD0sbO6MupiIb-IHLxEUGU5beBZwmIiBncc,542
-content_core/notebooks/docling.ipynb,sha256=aTad8NORNd-TUMlbX58DURJ4-QCeplTeTT0vUj301m0,631
-content_core/notebooks/run.ipynb,sha256=vmOYratdx0MnhNChjq3I5b7K2iYWuqO2dECK4Dp0jbU,369422
-content_core/processors/audio.py,sha256=jDn0_6F5dLcmz_C-iR80uOqOIAz49ELya2R5JeM15vo,3538
+content_core/notebooks/run.ipynb,sha256=WPBNcQUNXR5MldNMghVcU4vE4ibrVmlANa80baQn8TA,371078
+content_core/processors/audio.py,sha256=KnwxK85X9qRyVziMhFd103kfHkE8qGB1D4yW5lYO90E,5701
 content_core/processors/docling.py,sha256=wQ8ThAcyrCy-c95QtgplQ9UZtjCZTddLD9y1_CrRtSQ,2111
 content_core/processors/office.py,sha256=DXkfmjqUhmhP6rJaO5Z5Y9sv-iK0zaPZ3waynFIPtsk,12153
 content_core/processors/pdf.py,sha256=9jf-eROAqw6yQwdlbsxPXsaJXY26hVG7nSTPH9n4afY,5301
@@ -28,14 +26,12 @@ content_core/processors/text.py,sha256=kKHA60-NYjLmCTYUnk8TdJxQQ0Shkg-K61Ezqaelz
 content_core/processors/url.py,sha256=yhAnvIlYKc13iZedwA0ck6h6wd2j6T-Q2NAtMen3hIs,6783
 content_core/processors/video.py,sha256=3WnZwTswvTLm8PtQhKwoqJ2BH6YZi62dMUjALwJiebo,5196
 content_core/processors/youtube.py,sha256=nM286Km7FLN0r1f-n-dRkqs6mSXxCo4YOhTeGzj7Suo,5798
-content_core/prompts/content/cleanup.jinja,sha256=elyjbm9O_AeOcxkG-kui5wjBIRiOQCicjm92I4NmoVA,693
-content_core/prompts/content/summarize.jinja,sha256=zLPbomfjA-tQZr-c_rOqvKhd55R8NN3Q2gLyLR1sKso,817
 content_core/tools/__init__.py,sha256=DuJmd7fE-NpDvLP8IW1XY5MUkAQcdks52rn2jk4N8jQ,231
 content_core/tools/cleanup.py,sha256=5IdKedsFyRQMdYzgFSKtsfyxJldbroXQXHesHICNENI,523
 content_core/tools/extract.py,sha256=-r2_jsuMMXyXxGVqWhh1ilNPo_UMYAbw3Pkp1FzPy5g,577
 content_core/tools/summarize.py,sha256=DPfeglLWB08q8SvHrsKpOKZ35XjduUDs2J02ISwjdj0,596
-content_core-0.5.0.dist-info/METADATA,sha256=3im9n4tqCrStAX1UkdR42NnODwwHggKeQJdYL_eX68U,10499
-content_core-0.5.0.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
-content_core-0.5.0.dist-info/entry_points.txt,sha256=9fGQUk6bxBVXj9PRwfWVPn54ClSEJV7J-KBLXtjOhQw,99
-content_core-0.5.0.dist-info/licenses/LICENSE,sha256=myj0z2T4qIkenCgLsRfx7Wk6UqCQNj5c7O14Qx4zpGg,1066
-content_core-0.5.0.dist-info/RECORD,,
+content_core-0.6.0.dist-info/METADATA,sha256=pn72ciBGpWE7tVvJ2j3NmQPmFB60cNrkHBmp5ziuyqk,10534
+content_core-0.6.0.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
+content_core-0.6.0.dist-info/entry_points.txt,sha256=9fGQUk6bxBVXj9PRwfWVPn54ClSEJV7J-KBLXtjOhQw,99
+content_core-0.6.0.dist-info/licenses/LICENSE,sha256=myj0z2T4qIkenCgLsRfx7Wk6UqCQNj5c7O14Qx4zpGg,1066
+content_core-0.6.0.dist-info/RECORD,,

content_core/notebooks/docling.ipynb

@@ -1,27 +0,0 @@
-{
- "cells": [
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "from docling.document_converter import DocumentConverter\n",
-    "\n",
-    "\n",
-    "source = \"/Users/luisnovo/dev/projetos/content-core/tests/input_content/file.docx\"\n",
-    "source_url = \"https://arxiv.org/pdf/2408.09869\"  # PDF path or URL\n",
-    "converter = DocumentConverter()\n",
-    "result = converter.convert(source)\n",
-    "print(result.document.export_to_markdown())"
-   ]
-  }
- ],
- "metadata": {
-  "language_info": {
-   "name": "python"
-  }
- },
- "nbformat": 4,
- "nbformat_minor": 2
-}

content_core/prompter.py

@@ -1,159 +0,0 @@
-"""
-A prompt management module using Jinja to generate complex prompts with simple templates.
-"""
-
-import os
-from dataclasses import dataclass
-from datetime import datetime
-from typing import Any, Dict, Optional, Union
-
-from dotenv import load_dotenv
-from jinja2 import Environment, FileSystemLoader, Template
-from langchain_core.prompts import ChatPromptTemplate
-from pydantic import BaseModel
-
-from content_core.logging import logger
-
-load_dotenv()
-
-prompt_path_default = os.path.join(
-    os.path.dirname(os.path.abspath(__file__)), "prompts"
-)
-prompt_path_custom = os.getenv("PROMPT_PATH")
-
-logger.debug(
-    f"Pasta de prompts personalizada: {prompt_path_custom if prompt_path_custom else 'Não definida'}"
-)
-logger.debug(f"Pasta de prompts padrão: {prompt_path_default}")
-
-env_custom = (
-    Environment(loader=FileSystemLoader(prompt_path_custom))
-    if prompt_path_custom and os.path.exists(prompt_path_custom)
-    else None
-)
-env_default = Environment(loader=FileSystemLoader(prompt_path_default))
-
-
-@dataclass
-class Prompter:
-    """
-    A class for managing and rendering prompt templates.
-
-    Attributes:
-        prompt_template (str, optional): The name of the prompt template file.
-        prompt_variation (str, optional): The variation of the prompt template.
-        prompt_text (str, optional): The raw prompt text.
-        template (Union[str, Template], optional): The Jinja2 template object.
-    """
-
-    prompt_template: Optional[str] = None
-    prompt_variation: Optional[str] = "default"
-    prompt_text: Optional[str] = None
-    template: Optional[Union[str, Template]] = None
-    parser: Optional[Any] = None
-
-    def __init__(self, prompt_template=None, prompt_text=None, parser=None):
-        """
-        Initialize the Prompter with either a template file or raw text.
-
-        Args:
-            prompt_template (str, optional): The name of the prompt template file.
-            prompt_text (str, optional): The raw prompt text.
-        """
-        self.prompt_template = prompt_template
-        self.prompt_text = prompt_text
-        self.parser = parser
-        self.setup()
-
-    def setup(self):
-        """
-        Set up the Jinja2 template based on the provided template file or text.
-        Raises:
-            ValueError: If neither prompt_template nor prompt_text is provided.
-        """
-        if self.prompt_template:
-            # Primeiro tenta carregar da pasta personalizada, se disponível
-            if env_custom:
-                try:
-                    self.template = env_custom.get_template(
-                        f"{self.prompt_template}.jinja"
-                    )
-                    logger.debug(
-                        f"Template {self.prompt_template} carregado da pasta personalizada"
-                    )
-                    return
-                except Exception as e:
-                    logger.debug(
-                        f"Template {self.prompt_template} não encontrado na pasta personalizada: {e}"
-                    )
-
-            # Se não encontrou na personalizada ou não há pasta personalizada, tenta a padrão
-            try:
-                self.template = env_default.get_template(
-                    f"{self.prompt_template}.jinja"
-                )
-                logger.debug(
-                    f"Template {self.prompt_template} carregado da pasta padrão"
-                )
-            except Exception as e:
-                raise ValueError(
-                    f"Template {self.prompt_template} não encontrado na pasta padrão: {e}"
-                )
-        elif self.prompt_text:
-            self.template = Template(self.prompt_text)
-        else:
-            raise ValueError("Prompter must have a prompt_template or prompt_text")
-
-        assert self.prompt_template or self.prompt_text, "Prompt is required"
-
-    def to_langchain(self):
-        if isinstance(self.template, str):
-            template_text = self.template
-        else:
-            # For file-based templates, read the raw content
-            template_path = os.path.join("prompts", f"{self.prompt_template}.jinja")
-            with open(template_path, "r") as f:
-                template_text = f.read()
-        return ChatPromptTemplate.from_template(template_text, template_format="jinja2")
-
-    @classmethod
-    def from_text(cls, text: str):
-        """
-        Create a Prompter instance from raw text, which can contain Jinja code.
-
-        Args:
-            text (str): The raw prompt text.
-
-        Returns:
-            Prompter: A new Prompter instance.
-        """
-
-        return cls(prompt_text=text)
-
-    def render(self, data: Optional[Union[Dict, BaseModel]] = {}) -> str:
-        """
-        Render the prompt template with the given data.
-
-        Args:
-            data (Union[Dict, BaseModel]): The data to be used in rendering the template.
-                Can be either a dictionary or a Pydantic BaseModel.
-
-        Returns:
-            str: The rendered prompt text.
-
-        Raises:
-            AssertionError: If the template is not defined or not a Jinja2 Template.
-        """
-        # Convert Pydantic model to dict if necessary
-        data_dict = data.model_dump() if isinstance(data, BaseModel) else data
-        # Create a new mutable dictionary with the original data
-        render_data = dict(data_dict)
-        render_data["current_time"] = datetime.now().strftime("%Y-%m-%d %H:%M:%S")
-        if self.parser:
-            render_data["format_instructions"] = self.parser.get_format_instructions()
-        assert self.template, "Prompter template is not defined"
-        assert isinstance(
-            self.template, Template
-        ), "Prompter template is not a Jinja2 Template"
-        return self.template.render(render_data)
-        return self.template.render(render_data)

content_core/prompts/content/cleanup.jinja

@@ -1,16 +0,0 @@
-# GOAL
-
-Adjust the content below to make it clean and readable:
-Remove repeated strings that do not add value to the text.
-
-Remove any content unrelated to the text itself (e.g., metadata, artifacts, or extraction errors).
-
-Format the output as unstructured but clear text.
-
-Do not add extra text, introductions, conclusions, or commentary—only rewrite the provided content as it is.
-
-Do not interpret, analyze, or alter the meaning, intent, or narrative of the text—just reformat it for clarity and readability.
-
-Do not change the text structure, do not write conclusions about it. Your only job is to make it readable. 
-
-Keep the text in its original language, regardless of what it is.

content_core/prompts/content/summarize.jinja

@@ -1,25 +0,0 @@
-You are an AI assistant for a personal study platform.
-
-In this platform, your user collects various articles and content from the Internet for reference and study.
-
-Your role is to summarize the selected content as densely as possible, helping the reader extract maximum value from it without reading the full text.
-Focus solely on the content's value, avoiding unnecessary comments or messages.
-
-The summary should be dense, rich in characters, and designed to create a powerful vector representation.
-If the user provided additional context, follow its instructions. Otherwise, summary the whole content.
-
-Do not return any acknowledgments or greetings—only the summary.
-
-CONTENT:
-
-{{ content }}
-
-{% if context %}
-CONTEXT:
-
-User has provided the aditional context for your task:
-{{context}}
-{% endif%}
-
-
-SUMMARY: