With the exponential growth in the volume of data generated globally, organizations face a mounting challenge to extract meaningful and actionable insights. The need for robust summarization systems has become increasingly critical, particularly in environments that demand quick and data-driven decision-making. However, conventional LLM-based solutions fall short due to several persistent limitations:

• Token window constraints: State-of-the-art models like Llama2-13B have token windows that are capped at approximately 4,000 tokens. This limitation necessitates segmenting large documents, which often disrupts the narrative and compromises context.
• Heterogeneous data complexity: Enterprises must process data from various formats such as email messages, structured tables, audio call transcripts, and handwritten notes. Parsing and normalizing this data while preserving the intended meaning is a complex challenge.
• Accuracy and hallucination: LLMs can generate plausible yet incorrect or irrelevant content, known as hallucinations, thereby diminishing the reliability of generated summaries.
• Domain knowledge gap: Generic training data renders LLMs less effective in specialized domains, where nuanced understanding and industry-specific terminology are essential.

In today’s fast-paced business environment, enterprises are inundated with vast amounts of unstructured data originating from customer interactions, support tickets, market research, and internal communications. The challenges businesses face include:

• Information overload: Employees spend a significant amount of time sifting through large volumes of data to find relevant information, leading to decreased productivity.
• Delayed decision-making: Critical decisions are often postponed due to the time required to analyze extensive datasets, which can result in missed opportunities.
• Inconsistent communication: Without concise summaries, information sharing across departments becomes inefficient, leading to misunderstandings and fragmented knowledge.
• Customer dissatisfaction: In the context of customer support, slow response times and inadequate issue resolution stem from the inability to quickly assimilate customer history and previous interactions.

Dell Technologies and the authors of this document welcome your feedback on the solution and the solution documentation. Contact the Dell Technologies Solutions team by email.

Authors:Hediyeh Ledbetter, Harshit Nainwani, Sai Abhishek Pidaparthi, Radhika Soni

Dell Technologies and the authors of this document welcome your feedback on the solution and the solution documentation. Contact the Dell Technologies Solutions team by email.

Authors:Hediyeh Ledbetter, Harshit Nainwani, Sai Abhishek Pidaparthi, Radhika Soni

The field of text summarization has evolved significantly with the advent of Large Language Models (LLMs). Traditional approaches primarily relied on extractive methods, which select key sentences or phrases from the original text. These methods, though computationally efficient, often lack coherence and fail to capture the underlying essence and contextual relevance of the content 16.

With the advent of neural network-based models, the landscape of text summarization shifted towards more sophisticated techniques. Seq2Seq architectures, initially proposed for machine translation, became a cornerstone for abstractive summarization, where new sentences are generated to encapsulate the meaning of the source material 17. These models introduced a greater degree of linguistic flexibility and coherence, although challenges such as factual inconsistency and lack of domain adaptability persisted .

The introduction of attention mechanisms, and later the Transformer architecture, revolutionized text summarization tasks. Attention-based models allow for the dynamic weighting of source text segments, enabling the model to focus on the most relevant parts of the text during generation 20. Transformers, particularly the BERT model, demonstrated the power of pretrained contextual embeddings, enhancing both extractive and abstractive summarization pipelines 20. BERTSUM, an extension of BERT that is tailored for summarization, showed significant improvements in extractive summarization tasks by leveraging contextualized embeddings and fine-tuned attention layers.

The emergence of LLMs such as GPT and BART brought unprecedented advances in both language understanding and generation. These models leverage massive pretraining on diverse datasets followed by fine-tuning for specific summarization tasks. BART, a denoising autoencoder-based model, was particularly effective in abstractive summarization. BART particularly excelled in coherence and readability 21. Meanwhile, GPT-based models have showcased impressive zero-shot and few-shot capabilities, enabling summarization tasks with minimal fine-tuning 1.

Recent innovations also explore hybrid approaches that combine the strengths of extractive and abstractive methods. These hybrid models use extractive summarization to identify salient content, which is then refined and rephrased by abstractive mechanisms 22. Also, reinforcement learning techniques have been applied to optimize summarization models against human-centric evaluation metrics such as ROUGE and BLEU, further aligning model outputs with human preferences 2.

Domain-specific summarization is another emerging area of interest, particularly for legal, medical, and financial texts. These domains demand not only linguistic fluency but also domain expertise to ensure accuracy and relevance. Models fine-tuned on specialized datasets, often augmented with external knowledge bases, are increasingly being developed to address these needs 24.

Finally, the evaluation of summarization systems has seen considerable evolution. While traditional metrics like ROUGE and BLEU remain widely used, they often fail to account for semantic accuracy and coherence. Recent works advocate for the integration of model-based evaluation metrics, such as BERTScore and QAEval, which better capture the quality of generated summaries by aligning them with human evaluations 25.

This rich trajectory in text summarization research underscores the dynamic interplay between algorithmic advancements and the increasing demands for high-quality summarization across diverse domains. The integration of LLMs into summarization tasks continues to push the boundaries of what these systems can achieve, offering more coherent, concise, and contextually aware summaries than ever before.

The initial step in our pipeline involves robust data preprocessing to handle the heterogeneity of enterprise data as shown in Figure 1. This step ensures that all data is in a uniform format that is suitable for analysis by the LLM. Key preprocessing techniques include:

• Normalization: Converts varied data formats (such as, structured tables, call transcripts, email messages) into a unified text representation.
• Noise reduction: Filters out nonessential information such as boilerplate language, irrelevant metadata, and repetitive content.
• PII redaction: Employs algorithms to detect and remove personally identifiable information, ensuring compliance with privacy regulations.

The overlapping method ensures continuity across segments by strategically including repeated tokens at the boundaries of adjacent chunks. This redundancy helps maintain the narrative flow and ensures that essential context is not lost when the language model processes each segment. The key features of the overlapping method are as follows:

• Chunk design:
  • Each data segment (C_i ) overlaps with the adjacent chunks (C_i-1 , C _i+1), sharing key context elements (such as, preceding sentences or phrases) at the start or end of the chunk as shown in Figure 3.
  • The overlap length is parameterized to balance context retention and computational efficiency.

• Mathematical model:

  C_i = chunk_main(i) ∪ overlap_pre(i − 1) ∪ overlap_post(i + 1) where:

  • chunk_main(i): The main content of chunk i.
  • overlap_pre(i − 1): The overlapping portion that is shared with the previous chunk.
  • overlap_post(i + 1): The overlapping portion that is shared with the next chunk.
• Advantages:
  • Prevents loss of critical context between chunks.
  • Reduces the likelihood of fragmented or disjointed summaries.
  • Enhances consistency in multistage summarization pipelines.
• Limitations:
  • Increases computational costs due to overlapping tokens.
  • Redundancy in the processing of shared tokens.

The nonoverlapping method processes chunks independently, without shared tokens at their boundaries. This method is designed to maximize efficiency while relying on the model’s inherent ability to integrate context during postprocessing. The key features of this method are as follows:

• Chunk design:
  • Each data segment (C_i) is processed as a self-contained unit, without explicit overlaps as shown in Figure 2.
  • Context is preserved through model-driven mechanisms, such as attention weights and learned parameters.
• Mathematical Model:

  C_i = chunk_main(i)

  where chunk_main(i) is the isolated content of the i-th chunk.

• Advantages:
  • Reduces computational costs due to the absence of overlapping tokens.
  • Simplifies chunk segmentation and processing.
• Limitations:
  • Risk of losing critical context between independently processed chunks.
  • May result in fragmented summaries if a previous chunk’s summary misses critical narrative elements, especially when the story heavily relies on connections between chunks.

    

The overlapping and nonoverlapping methods serve different purposes and can be chosen based on the specific requirements of the summarization task:

• Overlapping method: Suitable for tasks requiring high coherence and continuity, particularly in narrative-heavy or context-dependent texts.
• Nonoverlapping method: Ideal for efficiency-driven tasks where preserving context between chunks is less critical or can be handled by postprocessing mechanisms.

The nonoverlapping method offers several notable advantages:

• Computational efficiency: By avoiding token redundancy, the nonoverlapping method significantly reduces computational costs, making it ideal for scenarios with resource constraints.
• Simplicity in chunking: The absence of overlapping regions simplifies the preprocessing pipeline, enabling faster implementation and reduced complexity.
• Scalability: This method scales well for large datasets, as independent chunk processing minimizes memory overhead.
• Task-specific prompting: By allowing each chunk to be handled separately, the nonoverlapping method facilitates task-specific prompts tailored to the content of each individual chunk.
• Reduced token usage: The total token usage is minimized, maximizing the efficiency of token-limited language models.

Despite its advantages, the nonoverlapping method has certain limitations:

• Potential context loss: The absence of explicit overlap can lead to loss of critical context between chunks, especially in narrative-heavy or sequential data.
• Dependency on model mechanisms: Coherence and continuity heavily depend on the model’s ability to infer relationships between independently processed chunks, which may not always be reliable.
• Postprocessing overhead: Additional steps, such as reintegrating chunked summaries into a cohesive whole, may be required during postprocessing.

For production-level summarization, we have opted for the nonoverlapping method due to its superior scalability and computational efficiency. In large-scale enterprise use cases, such as customer support summarization or document analysis, the nonoverlapping approach enables:

• Faster processing speeds for high-volume datasets.
• Simplified implementation pipelines, reducing operational overhead.
• Optimized token usage, ensuring compatibility with models with limited token windows.

By leveraging structured prompts and postprocessing techniques, the nonoverlapping method achieves high-quality summaries while meeting the demands of production environments. This choice aligns with the requirement for fast, reliable, and scalable summarization solutions across various domains.

Given a large dataset D, which needs to be summarized using a Large Language Model (LLM) with a limited token window W, the chunking process becomes a crucial step to divide the data into manageable pieces while maintaining context continuity.

Let:

• D represent the full dataset with a total token count T.
• W denote the maximum token window size of the LLM.
• n represent the number of chunks into which the dataset is divided.

The dataset D is segmented into n chunks {D₁, D₂,...,D_n}, where each chunk D_i has a token count t_i such that:

t_i ≤ W for all i = 1,2,...,n

The goal is to minimize the number of chunks n while ensuring that all t_i s fit within the LLM’s token window.

To maintain context between chunks, we introduce an overlap O between consecutive chunks.

Let:

• a represent the overlap ratio, where 0 ≤ a ≤ 1.
• The overlap token count O_i for chunk D_i is given by:

  O_i = α × t_i

The overlap O_i ensures that important context from the end of chunk is preserved in the beginning of chunk D_i+1 . This overlap allows the summarization to remain coherent across all chunks.

The summarization process for each chunk D_i is initiated using a structured prompt, P_i, which takes into account:

• The content of chunk D_i
• The context C_i−1 from the previous chunk’s overlap

The initial prompt P_i can be mathematically represented as:

P_i = GenerateSummary(D_i, C_i−1 )

where:

• GenerateSummary is the function that is used to guide the LLM in generating the summary.
• C_i−1 is the extracted context from the overlap O_i−1 of the previous chunk.

The final summary S of the entire dataset D is constructed by sequentially combining the summaries from each chunk while resolving any redundancies or inconsistencies:

S = CombineSummaries(S₁,S₂,...,S_n)

Where CombineSummaries is an operation that ensures the entire summary is coherent and comprehensive, leveraging the overlapping O_i to stitch together the chunks effectively.

In the nonoverlapping method, chunks are processed independently without shared tokens at their boundaries. Instead of direct overlap, coherence is maintained through model-driven mechanisms, such as attention weights or structured prompts.

Let:

• α represent the nonoverlapping ratio, where α = 1 (indicating no overlap).
• The token count t_i for chunk D_i is given by:

t_i = length of D_i

Since there is no explicit overlap (O_i = 0), context from one chunk is not directly carried over to the next. Coherence and continuity are preserved during postprocessing or by incorporating prior context through prompts or model fine-tuning.

The summarization process for each chunk D_i is initiated using a structured prompt, P_i, which takes into account:

• The content of chunk D_i
• The context C_i−1 from the previous chunk’s overlap

The initial prompt P_i can be mathematically represented as:

P_i = GenerateSummary(D_i, C_i−1 )

where:

• GenerateSummary is the function that is used to guide the LLM in generating the summary.
• C_i−1 is the extracted context from the overlap O_i−1 of the previous chunk.

In the design of our summarization solution, we have considered both overlapping and non-overlapping methods to ensure that the system can meet a range of performance and coherence needs. These choices are reflected within the Context Creator and Summary Generator components of our prompt engineering pipeline. Specifically, the Context Creator leverages overlapping segments to maintain continuity across related pieces of information, while the Summary Generator can adapt its chunking strategy based on the chosen method. By delineating these two approaches—one that favors richly coherent context integration and another that emphasizes computational efficiency—we enable the system to flexibly cater to various summarization requirements, from producing highly comprehensive narratives to facilitating faster, more streamlined processing.

At the core of our approach is a carefully designed prompt engineering pipeline. This pipeline systematically deconstructs the summarization task into a sequence of interlinked components, each contributing to the final output’s clarity, accuracy, and usability. The pipeline includes several key stages, each with a distinct objective:

The Summary Generator stage serves as the initial engine that crafts detailed, contextually rich summaries for each segmented data chunk. Employing a sequence of structured prompts, it ensures that essential technical details and domain-specific jargon are accurately identified and represented. This structured approach guides the language model through the data, extracting key insights and forming the building blocks of our final summaries.

Next, the ContextCreator stage preserves continuity as the system processes multiple chunks. It identifies core elements that collectively define the narrative, including the issues customers face, the resolutions offered, and the critical troubleshooting steps applied. Formally, we represent the overall context C across n chunks as C = f(C1, C2, ..., Cn; θ, P), where f is a learned integration function, θ represents the model’s parameters, and P indicates the guiding prompt rules. This mathematical abstraction captures how the system prioritizes and filters contextual information, ensuring that only the most relevant and meaningful elements persist and providing a coherent and comprehensive story of what has transpired.

As new information becomes available, the Update Composer dynamically incorporates these updates into existing summaries. Instead of replacing what has already been established, this component merges new insights with prior data, ensuring that each summary remains both current and consistent with previously derived conclusions. The approach maintains a delicate balance between fresh information and the previously integrated narrative, preventing the repetition of content and preserving narrative flow.

Over time, as the underlying data evolves, the Summary Refresher revisits the integrated summary to validate its accuracy and completeness. Through iterative probing techniques, it identifies inconsistencies, resolves ambiguities, and refreshes the entire narrative to ensure it aligns with the most recent understanding. By doing so, it reduces the risk of error propagation and ensures that the final summaries remain both reliable and timely.

To ensure that the finalized content meets the highest standards of readability, adherence to business requirements, and compliance, the Summary Processor refines and sanitizes each summary. This stage removes redundant phrases, filters out irrelevant content, and applies strict formatting rules. It further protects sensitive information through automated checks and advanced detection mechanisms, incorporating both sophisticated regular expressions and ML-based models capable of identifying and redacting personally identifiable information.

Finally, the Summary Translator expands the global reach of these summaries by translating them into multiple languages. By using translation models optimized for technical and domain-specific terminology, it ensures that the context, meaning, and nuances of the original summaries are faithfully preserved. This step closes the loop on delivering a universally accessible solution, making the summarization system valuable to stakeholders regardless of their linguistic and cultural backgrounds.

In essence, our prompt engineering pipeline embodies a flexible, rigorous, and globally-minded approach to automated summarization. By carefully integrating overlapping and non-overlapping strategies, domain-specific rules, continuous context management, iterative updates, refinement processes, and advanced translation capabilities, we have created a system that not only meets current business and technical requirements but also anticipates future needs. The result is a white paper that highlights a nuanced, data-driven, and human-centered method of generating comprehensive, accurate, and universally accessible summaries.

The effectiveness of the summarization process can be evaluated using a combination of automated and human-centric metrics:

• Bilingual Evaluation Understudy (BLEU): This metric quantifies the overlap between the generated summary and one or more reference summaries, focusing on n-gram precision. BLEU is defined as:

  where:

  • p_n : Precision of n-gram matches between the generated and reference summaries.
  • w_n : Weights that are assigned to each n-gram level, typically uniform.
  • BP: Brevity penalty, applied to discourage excessively short summaries.
  • A higher BLEU score indicates greater lexical alignment with reference summaries. Human-generated summaries were used as references to compute BLEU, ensuring alignment with expert judgments.

• Human evaluation metrics: In addition to BLEU, human evaluators assess qualitative aspects of the summary, including:
  • Coherence: Measures logical flow and connection between ideas.
  • Fluency: Evaluates grammatical correctness and readability.
  • Informativeness: Assesses how well the summary retains key information from the source text.
  • Human evaluation provides a subjective yet critical perspective on the quality of the summarization, addressing nuances that BLEU may not capture.

Our approach is distinguished by several innovative techniques:

• Advanced prompt chaining: Sequentially refines summaries, ensuring that the output is coherent and context-aware.
• Iterative probing for hallucination mitigation: Uses iterative prompts to minimize the risk of hallucinations by nudging the LLM to focus on verifiable data.
• Granular context extraction: Content Creator intelligently categorizes and retains crucial information, enabling consistent narrative flow.
• Error propagation management: Quality control mechanisms that are embedded within the Summary Process help mitigate error cascades.

• Contextual incoherence: Existing methods often produce disjointed summaries that lack narrative flow.
• High costs and complexity: Fine-tuning models is expensive and requires large volumes of labeled training data.
• Generic outputs: LLMs trained on general datasets fail to capture domain-specific nuances.

• Holistic summarization: Our method maintains narrative consistency and cohesiveness, even across segmented data.
• Cost-effective scalability: The modular design minimizes computational overhead, making the solution scalable.
• Domain-specific adaptability: Custom rules and prompts make the system highly effective across different industries, without the need for extensive retraining.

Our solution is designed to adapt to evolving LLM architectures. As models with larger token capacities become available, such as Mixtral-8x7B with a context window of 32,000 tokens, our modular design ensures that we can leverage these advancements without sacrificing granularity or precision.

Existing LLM-based summarization techniques generally involve:

• Chunk-based summarization: Leads to fragmented and incoherent summaries due to context loss between chunks.
• Fine-tuning LLMs: Resource-intensive and often impractical in dynamic environments where data evolves rapidly.
• Retrieval-augmented generation (RAG): While useful for incorporating external knowledge, it struggles with models that have limited token capacities.

Our summarization system is designed with scalability in mind, ensuring that it can handle large datasets and adapt to advancements in LLM technology. Scalability is achieved through several key design principles:

The chunking mechanism divides the full dataset D into smaller chunks {D₁,D₂,...,D_n }, each processed independently without overlapping tokens. This approach allows for:

• Efficient memory utilization: By processing smaller, self-contained chunks, we avoid exceeding the LLM’s token limit W, enabling the system to handle large datasets efficiently without running out of memory.
• Parallel processing: Since chunks are independent, summarization tasks can be distributed across multiple processors or machines. This parallelization significantly reduces the time that is required for large-scale summarization, while eliminating the computational overhead of managing overlapping tokens.
• Modular Architecture: Each component of the pipeline (such as, Summary Generator or Postprocessor) can be optimized separately or scaled independently. This modular design provides flexibility to adjust different data volumes, processing requirements, and computational resources.

By employing the nonoverlapping chunking method, we achieve an efficient and scalable summarization system that aligns with the demands of production environments.

The system is designed to take advantage of future improvements in LLM architectures. As models with larger token windows become available, the chunking strategy can be adjusted to use fewer chunks with more tokens per chunk, improving efficiency while maintaining summary quality.

We use carefully crafted prompts to guide the LLM in extracting the most relevant information from each chunk. Structured prompting provides clear instructions, reducing ambiguity and improving the model’s performance. For example, a typical prompt may specify:

• The type of information to extract (such as, key issues, resolutions)
• The wanted format of the output (such as, bullet points, concise paragraphs)

Prompt chaining involves a series of prompts where each prompt builds on the output of the previous one. This technique allows for iterative refinement, ensuring that the final summary:

• Captures all essential details.
• Maintains narrative continuity across data chunks.
• Reduces redundancy and enhances coherence.

To minimize hallucinations and errors, we employ iterative probing. This involves using multiple prompts to validate and refine the information that is extracted from the data. The LLM is repeatedly nudged towards producing verifiable and accurate content, which is especially important in technical or high-stakes environments.

• Improved decision-making: Comprehensive and up-to-date summaries allow support agents to make faster and more informed decisions.
• Operational efficiency: Automation reduces the need for manual data review, enabling agents to focus on higher-value tasks.
• Enhanced customer experience: Faster issue resolution times and more accurate support interactions lead to greater customer satisfaction and loyalty.

By customizing prompts with domain-specific language and rules, our system becomes highly effective for specialized applications. For example, in the automotive sector, prompts can be tailored to recognize and prioritize technical terms, making the summaries more accurate and useful.

Our solution has broader applications beyond Dell, offering value in multiple sectors:

• Automotive sector: Streamlines the diagnostic process by summarizing repair histories and multi-technician case notes.
• Product reviews and consumer insights: Aggregates customer feedback, providing brands with actionable insights.
• Healthcare: Summarizes patient records, enabling medical professionals to make informed decisions quickly.

Our advanced engineering and optimization techniques revolutionize the field of LLM-based summarization by offering a solution that is not only scalable and modular but also inherently context-aware. The proposed methodology successfully overcomes persistent challenges, such as limited token windows, fragmented outputs, and hallucinations, by employing a combination of structured prompt engineering, precise context management, and iterative summarization strategies. These innovations collectively ensure that the summarization process is both coherent and comprehensive, even when processing extensive datasets that exceed the token capacity of the underlying language models.

While we have gained valuable experience working with both overlapping and nonoverlapping chunking methods, our production implementation prioritizes the nonoverlapping approach. This decision stems from its superior computational efficiency, scalability, and simplicity in handling large datasets. By treating each chunk as an independent unit, the nonoverlapping method eliminates token redundancy and enables faster processing, making it ideal for real-world, high-volume applications. However, insights from overlapping techniques, particularly in bridging gaps across chunks, have influenced our prompt design and postprocessing strategies to ensure continuity and coherence.

The mathematical underpinnings of our chunking and context management approach remain key to its success. By dividing input data into manageable, self-contained chunks, we ensure that the narrative flow and critical information are preserved throughout the summarization pipeline. Structured prompts and advanced postprocessing techniques compensate for the absence of explicit overlaps, enabling the generation of summaries that retain the essence and coherence of the original input.

Our evaluation framework further underscores the effectiveness of our solution. Using quantitative metrics like BLEU scores alongside qualitative human evaluations, we validated the system’s ability to produce accurate and meaningful summaries. Notably, human evaluators reported an accuracy of approximately 90%, reflecting the system’s capacity to generate summaries that are not only precise but also contextually and semantically rich. These metrics, combined with measures such as redundancy reduction and compression ratios, provide a robust foundation for refining and optimizing the methodology, ensuring its alignment with real-world demands.

Also, the forward-compatible design of our solution positions it for seamless integration with future advancements in LLM architectures, such as models with significantly larger token capacities or improved attention mechanisms. This adaptability ensures the long-term viability of our framework in a rapidly evolving technological landscape. The modular architecture also facilitates easy customization and domain-specific tuning, making it highly suitable for diverse industries, including but not limited to healthcare, finance, automotive diagnostics, and customer support.

Ultimately, this white paper demonstrates how our summarization system enhances data-driven decision-making and operational efficiency across various applications. By automating the extraction of actionable insights from vast and complex datasets, our solution empowers organizations to respond more quickly and effectively to challenges, delivering tangible benefits such as improved customer experiences, reduced operational costs, and faster resolutions. With this approach, we establish a new benchmark for summarization technology, paving the way for more sophisticated, efficient, and scalable applications in the future.

In summary, our solution reflects a balanced approach, informed by experience with overlapping techniques yet optimized for the nonoverlapping method in production settings. By blending advanced engineering, rigorous evaluation, and future-ready design, it sets a strong precedent for the next generation of summarization technologies, ensuring that they remain robust, adaptable, and impactful in addressing the growing demands of the digital age.

This section provides examples of prompts used in the study for generating text summaries with Large Language Models (LLMs).

system_prompt : |

Dell is a computer manufacturer, you’re given data regarding a customer’s interaction with an agent from Dell. The interaction involves cases being created, tasks being performed by the agent on the support case to help resolve the customers issue. Cases in general include customers facing issues with their system, and contacting Dell regarding it. Agent is dell’s representative, and customer is Dell’scustomer. You are an assistant, who creates detailed and comprehensible technical case updates which can be understood by agent’s manager.

Follow these rules while generating the paragraph:

1. Be sure to include important information like troubleshooting done by agent and any issues faced by customer in your paragraph.
2. Focus is on customers journey with the agent. Identify pain points/friction in the customer journey, if any.
3. Do not include Customer agent names.
4. Do not include task numbers.
5. Do not include mentions of follow-ups, emails sent, or general communications unless they contain specific information relevant to the case.
6. Do not include any explanations and raw data.
7. Follow a chronological order while generating to ensure cohesiveness.

assist_prompt: |

I will provide three tables case, task, workorder table. The first row under DATA is the header.

case table contains casenumber, case create date, case tile and case closed date. DATA:

{case_data}

task table contains the task history for a customer’s asset. A Task is any activity on the case. The definition for each column is as follows: {column_definitions} DATA:

{task_data}

{case_closed_str}

Do not generate an output yet.

user_prompt : |

Your task is to create a clear and concise ‘case_observations‘ from your observations.

You will respond ONLY with a JSON object with the key ‘case_observations‘ and value ‘technical updates in one paragraph‘.

DO NOT give any explanations.

Example for formatting:

‘‘‘json

{{"case_observations": "A case was created on..."}}

‘‘‘

Your Output starts below: ‘‘‘json

system_prompt: |

<|begin_of_text|><|start_header_id|>user<|end_header_id|>

You are an expert at cleaning and generating condensed paragraphs from bullets. You will be provided certain case information which might include recent updates in bullet format.

Your goal is to generate a better version as a paragraph embedded in JSON format following the rules below:

1. Remove duplicate information, if exists.
2. Do not include any information outside of bullet points provided/Do not fabricate an answer.
3. Must explore all the bullet points provided for creating a cohesive paragraph.
4. If recent updates are not mentioned, you can mention no recent updates.
5. Strictly output in json format.
6. The bullets are in ascending chronological order from beginning of the case to current.
7. Do include case create/close dates only when provided.
8. Focus on including recent troubleshooting actions/steps/pain points if any on the case while concisely presenting the history.
9. Call scheduling/follow up related information is redundant, and can be avoided.

user_prompt: |

Read ALL the bullets from START to END below before generating an output, every bullet is crucial, and the chronology is important.

This is the given case information and might include recent updates in bullet points : START ""{summary}"" END

Don’t give any extra explanations/notes, just the output in JSON format is enough.

Output should strictly be in JSON with only one key ("cleaned_output") using the following format:

{{"cleaned_output": "concise and objective version of bulleted information in a paragraph following the guidelines in English goes here"}}

an Example output is - {{"cleaned_output":"The case was created on..."}}<|eot_id|>

<|start_header_id|>assistant<|end_header_id|>

This section provides snippets of code used in the experiments for training and evaluating summarization models.

function GetResponseV1(max_tokens, top_p, temp):

# Step 1: Construct instruction instruction = SystemPrompt + "\n" + AssistPrompt + "\n" + UserPrompt

# Step 2: Create request payload data = {

"prompt": instruction,

"temperature": temp,

"top_p": top_p,

"max_tokens": max_tokens,

"stream": False,

"model": ModelVersion,

"stop": ["<|eot_id|>", "<|end|>"]

}

# Step 3: Prepare HTTP headers headers = {

"accept": "application/json",

"api-key": Config["api-key"],

"Content-Type": "application/json" }

# Step 4: Set up timeout configuration timeout = Timeout(seconds=300)

# Step 5: Send asynchronous API request with AsyncClient(verify=False, timeout=timeout) as client:

response = client.post(url=Config["url"], headers=headers, json=data)