From fd54663c292acd8c12f9af2ca98d400ee19f7bdb Mon Sep 17 00:00:00 2001 From: Flavio Brasil Date: Thu, 21 Dec 2023 23:19:22 -0800 Subject: [PATCH] ais: improving thoghts --- .../scala/kyo/llm/thoughts/meta/Chain.scala | 7 ++-- .../kyo/llm/thoughts/meta/Constrain.scala | 12 +++--- .../scala/kyo/llm/thoughts/meta/Desc.scala | 10 ++--- .../scala/kyo/llm/thoughts/meta/Gen.scala | 10 ++--- .../scala/kyo/llm/thoughts/meta/Init.scala | 22 ++++------ .../scala/kyo/llm/thoughts/meta/Select.scala | 38 +++++++++--------- .../kyo/llm/thoughts/reasoning/Analysis.scala | 10 ++--- .../reasoning/Contextualization.scala | 14 ++++--- .../kyo/llm/thoughts/reasoning/Creative.scala | 40 +++++-------------- .../llm/thoughts/reasoning/Ecological.scala | 16 -------- .../llm/thoughts/reasoning/Emotional.scala | 27 ------------- .../kyo/llm/thoughts/reasoning/Empathy.scala | 19 +++++++++ .../llm/thoughts/reasoning/Evaluation.scala | 18 --------- .../thoughts/reasoning/Interpretation.scala | 18 --------- .../kyo/llm/thoughts/reasoning/Repair.scala | 17 ++++---- .../llm/thoughts/reasoning/Synthesis.scala | 18 --------- .../kyo/llm/thoughts/reasoning/Systems.scala | 32 ++++----------- 17 files changed, 101 insertions(+), 227 deletions(-) delete mode 100644 kyo-llm/shared/src/main/scala/kyo/llm/thoughts/reasoning/Ecological.scala delete mode 100644 kyo-llm/shared/src/main/scala/kyo/llm/thoughts/reasoning/Emotional.scala create mode 100644 kyo-llm/shared/src/main/scala/kyo/llm/thoughts/reasoning/Empathy.scala delete mode 100644 kyo-llm/shared/src/main/scala/kyo/llm/thoughts/reasoning/Evaluation.scala delete mode 100644 kyo-llm/shared/src/main/scala/kyo/llm/thoughts/reasoning/Interpretation.scala delete mode 100644 kyo-llm/shared/src/main/scala/kyo/llm/thoughts/reasoning/Synthesis.scala diff --git a/kyo-llm/shared/src/main/scala/kyo/llm/thoughts/meta/Chain.scala b/kyo-llm/shared/src/main/scala/kyo/llm/thoughts/meta/Chain.scala index 25c82d36e..9b51a20c2 100644 --- a/kyo-llm/shared/src/main/scala/kyo/llm/thoughts/meta/Chain.scala +++ b/kyo-llm/shared/src/main/scala/kyo/llm/thoughts/meta/Chain.scala @@ -6,10 +6,9 @@ object Chain { val chainDesc = p""" - The Chain thought enable sequential linking of multiple reasoning processes. - - Facilitates the flow of reasoning from one thought to another. - - Ensures coherence and logical progression in the reasoning chain. - - Allows complex reasoning to be broken down into manageable segments. + The Chain thought enable sequential linking of multiple reasoning processes. + - Facilitates the flow of reasoning from one thought to another. + - Ensures coherence and logical progression in the reasoning chain. """ } import Chain._ diff --git a/kyo-llm/shared/src/main/scala/kyo/llm/thoughts/meta/Constrain.scala b/kyo-llm/shared/src/main/scala/kyo/llm/thoughts/meta/Constrain.scala index 2144bd96c..55799d1f2 100644 --- a/kyo-llm/shared/src/main/scala/kyo/llm/thoughts/meta/Constrain.scala +++ b/kyo-llm/shared/src/main/scala/kyo/llm/thoughts/meta/Constrain.scala @@ -4,14 +4,14 @@ import kyo.llm.ais._ @desc( p""" - The Constrain thought is a tool for applying specific constraints to the AI's reasoning process. - - The `Apply specific constraints to the value generation` field, defined as a string literal type, outlines the nature of the constraints that should govern the AI's thought generation. - - The `value` is the main focus where the AI applies the defined constraints during its reasoning or output generation. - - This mechanism is instrumental in guiding the AI to produce results within specific parameters or conditions, enhancing the relevance and precision of the output. - - Example: Constrain["Must be within ethical guidelines", EthicalReasoning] would direct the AI to ensure that the reasoning adheres to ethical guidelines. + The Constrain thought applies specific constraints to the AI's reasoning. + - Outlines constraints in the 'Apply specific constraints to the value generation' field. + - 'value' is where the AI applies these constraints in its process. + - Aims to enhance output precision and relevance. + - Example: Constrain["Adhere to ethical guidelines", EthicalReasoning] guides the AI to follow ethical standards. """ ) case class Constrain[C <: String, T]( - `Apply specific constraints to the value generation`: C, + `Apply specific constraints`: C, value: T ) diff --git a/kyo-llm/shared/src/main/scala/kyo/llm/thoughts/meta/Desc.scala b/kyo-llm/shared/src/main/scala/kyo/llm/thoughts/meta/Desc.scala index 460f87422..52a5263c5 100644 --- a/kyo-llm/shared/src/main/scala/kyo/llm/thoughts/meta/Desc.scala +++ b/kyo-llm/shared/src/main/scala/kyo/llm/thoughts/meta/Desc.scala @@ -4,12 +4,10 @@ import kyo.llm.ais._ @desc( p""" - The Desc thought is designed to encapsulate a thought along with a user-defined description. - - 'desc' is a string literal type that acts as a label or a brief explanation of the thought process. - - 'value' is the actual thought or process that needs to be generated or executed. - - This class guides the LLM to focus on generating the 'value' based on the context provided by 'desc'. - - Example user code that generates this thought Desc["brainstorm something", Chain[Creative, Critical]] indicates - that the LLM should engage in a creative and critical thought chain under the theme of 'brainstorm something'. + The Desc thought pairs a user-defined description with a thought. + - 'desc': A label or brief explanation as a string literal. + - 'value': The actual thought or process to generate. + - Example: Desc["brainstorm", Chain[Creative, Critical]] guides the LLM for a brainstorming thought process. """ ) case class Desc[D <: String, T](desc: D, value: T) diff --git a/kyo-llm/shared/src/main/scala/kyo/llm/thoughts/meta/Gen.scala b/kyo-llm/shared/src/main/scala/kyo/llm/thoughts/meta/Gen.scala index 554026d3d..7fac38fed 100644 --- a/kyo-llm/shared/src/main/scala/kyo/llm/thoughts/meta/Gen.scala +++ b/kyo-llm/shared/src/main/scala/kyo/llm/thoughts/meta/Gen.scala @@ -4,11 +4,11 @@ import kyo.llm.ais._ @desc( p""" - The Gen thought is structured to facilitate the generation of a specific outcome based on a given thought process. - - The 'thought' field represents the thought process or reasoning approach that the AI should use. - - The 'value' field is the specific outcome or result that should be generated using the specified thought process. - - This thought encourages the AI to apply a particular reasoning method (as defined in 'thought') to produce a desired output (as specified in 'value'). - - Example: Gen[Analysis, "Potential solutions to a problem"] would direct the AI to use analytical reasoning to generate potential solutions to the given problem. + The Gen thought links a specific reasoning approach with a desired outcome. + - 'thought': The reasoning method to be applied. + - 'value': The outcome to be generated. + - Guides the AI in applying the chosen reasoning to produce the specified result. + - Example: Gen[Analysis, "Solutions"] uses analysis to generate solutions. """ ) case class Gen[T, U]( diff --git a/kyo-llm/shared/src/main/scala/kyo/llm/thoughts/meta/Init.scala b/kyo-llm/shared/src/main/scala/kyo/llm/thoughts/meta/Init.scala index 3267b4bb7..79bc4eb47 100644 --- a/kyo-llm/shared/src/main/scala/kyo/llm/thoughts/meta/Init.scala +++ b/kyo-llm/shared/src/main/scala/kyo/llm/thoughts/meta/Init.scala @@ -4,23 +4,15 @@ import kyo.llm.ais._ @desc( p""" - The Init thought sets foundational guidelines for the LLM's reasoning process, especially in adhering to the JSON schema. - - **Crucially, the LLM must never generate arbitrary fields and should strictly follow the provided JSON schema.** - - This thought ensures that 'value' represents specific, predefined thoughts or reasoning steps. - - Acts as a blueprint for integrating thoughts into a logical and schema-compliant reasoning pathway. - - Aims for well-structured responses that align with the user's intent and adhere to JSON formatting rules. - - Fields focus on reflecting upon past errors and strategizing to avoid them, especially in maintaining JSON schema integrity. - - Example: A 'value' containing Chain[Analysis, Synthesis] should be elaborated in accordance with the schema, without adding extraneous fields. - - **The LLM is required to ensure compliance with the JSON schema at all times.** + The Init thought guides the LLM in structuring reasoning to align with JSON schema. + - Emphasizes schema compliance and logical reasoning. + - Aids in reflecting on and improving from past outputs. + - Ensures strict adherence to formatting rules. """ ) case class Init[T]( - `Have you failed at previous attempts to generate this json`: Boolean, - `Analysis of the previous failures`: String, - `Strategy to avoid another failure`: String, - `Elaborate on the strategy to avoid failures`: String, - `The generated json can't have new line characters`: Boolean, - `I understand I can't use new lines`: Boolean, - `Strictly adhere to the provided JSON schema without adding arbitrary fields`: Boolean, + `Reflect on past JSON errors`: Boolean, + `Strategy for JSON schema compliance`: String, + `Adhere strictly to JSON schema and formatting`: Boolean, value: T ) diff --git a/kyo-llm/shared/src/main/scala/kyo/llm/thoughts/meta/Select.scala b/kyo-llm/shared/src/main/scala/kyo/llm/thoughts/meta/Select.scala index 4767e5803..15cf49bf2 100644 --- a/kyo-llm/shared/src/main/scala/kyo/llm/thoughts/meta/Select.scala +++ b/kyo-llm/shared/src/main/scala/kyo/llm/thoughts/meta/Select.scala @@ -6,41 +6,41 @@ object Select { val SelectDesc = p""" - The Select thought facilitates the LLM's choice in focusing on particular reasoning processes. - - Enables selective expansion on specific thoughts based on relevance and significance. - - Provides flexibility in the reasoning pathway, allowing the LLM to prioritize and delve deeper into chosen thoughts. - - Encourages a targeted approach to reasoning, ensuring a more efficient and relevant output. - - The use of 'Option' in each thought or process allows for dynamic selection based on the context of the conversation. + The Select thought allows the LLM to focus on specific reasoning processes. + - Facilitates choice and prioritization of thoughts for relevance. + - Enables a flexible and targeted reasoning approach. + - Uses optional fields for dynamic thought selection based on context. """ } + import Select._ @desc(SelectDesc) case class Select[A, B]( - `First thought or process`: Option[A], - `Second thought or process`: Option[B] + `First thought`: Option[A], + `Second thought`: Option[B] ) @desc(SelectDesc) case class Select3[A, B, C]( - `First thought or process`: Option[A], - `Second thought or process`: Option[B], - `Third thought or process`: Option[C] + `First thought`: Option[A], + `Second thought`: Option[B], + `Third thought`: Option[C] ) @desc(SelectDesc) case class Select4[A, B, C, D]( - `First thought or process`: Option[A], - `Second thought or process`: Option[B], - `Third thought or process`: Option[C], - `Fourth thought or process`: Option[D] + `First thought`: Option[A], + `Second thought`: Option[B], + `Third thought`: Option[C], + `Fourth thought`: Option[D] ) @desc(SelectDesc) case class Select5[A, B, C, D, E]( - `First thought or process`: Option[A], - `Second thought or process`: Option[B], - `Third thought or process`: Option[C], - `Fourth thought or process`: Option[D], - `Fifth thought or process`: Option[E] + `First thought`: Option[A], + `Second thought`: Option[B], + `Third thought`: Option[C], + `Fourth thought`: Option[D], + `Fifth thought`: Option[E] ) diff --git a/kyo-llm/shared/src/main/scala/kyo/llm/thoughts/reasoning/Analysis.scala b/kyo-llm/shared/src/main/scala/kyo/llm/thoughts/reasoning/Analysis.scala index bc37cd7a7..ba0920f96 100644 --- a/kyo-llm/shared/src/main/scala/kyo/llm/thoughts/reasoning/Analysis.scala +++ b/kyo-llm/shared/src/main/scala/kyo/llm/thoughts/reasoning/Analysis.scala @@ -4,11 +4,11 @@ import kyo.llm.ais._ @desc( p""" - The Analysis thought breaks down the input into more manageable parts. - - Dissects the input into fundamental elements. - - Explores connections among elements. - - Critically assesses the validity and logic. - - Relevant techniques: Data Decomposition, Logical Analysis. + The Analysis thought breaks down the input into more manageable parts. + - Dissects the input into fundamental elements. + - Explores connections among elements. + - Critically assesses the validity and logic. + - Relevant techniques: Data Decomposition, Logical Analysis. """ ) case class Analysis( diff --git a/kyo-llm/shared/src/main/scala/kyo/llm/thoughts/reasoning/Contextualization.scala b/kyo-llm/shared/src/main/scala/kyo/llm/thoughts/reasoning/Contextualization.scala index 2d86f0486..6ec3b8d4e 100644 --- a/kyo-llm/shared/src/main/scala/kyo/llm/thoughts/reasoning/Contextualization.scala +++ b/kyo-llm/shared/src/main/scala/kyo/llm/thoughts/reasoning/Contextualization.scala @@ -4,15 +4,17 @@ import kyo.llm.ais._ @desc( p""" - The Contextualization thought involves placing the input within a broader framework. - - Assesses the relationship of input to previous discussions or knowledge. - - Identifies broader context relevant to the input. - - Considers implications of external factors. - - Relevant techniques: Context Analysis, Pattern Recognition. + The Contextualization thought involves placing the input within a broader framework. + - Assesses the relationship of input to previous discussions or knowledge. + - Identifies broader context relevant to the input. + - Considers implications of external factors. + - Relevant techniques: Context Analysis, Pattern Recognition. """ ) case class Contextualization( + `Determine the core message or question in the input`: String, `Assess how the current input relates to previous discussions or knowledge`: String, `Identify the broader context or background relevant to the input`: String, - `Consider the implications of external factors or related concepts`: String + `Consider the implications of external factors or related concepts`: String, + `Identify any ambiguous or unclear aspects that need further clarification`: String ) diff --git a/kyo-llm/shared/src/main/scala/kyo/llm/thoughts/reasoning/Creative.scala b/kyo-llm/shared/src/main/scala/kyo/llm/thoughts/reasoning/Creative.scala index f9ccbfbe6..e6d86fe8f 100644 --- a/kyo-llm/shared/src/main/scala/kyo/llm/thoughts/reasoning/Creative.scala +++ b/kyo-llm/shared/src/main/scala/kyo/llm/thoughts/reasoning/Creative.scala @@ -4,37 +4,17 @@ import kyo.llm.ais._ @desc( p""" - The Creative thought encourages creative and divergent thinking in AI processes. - - Draws on concepts from creative problem solving and design thinking. - - Utilizes divergent thinking models from cognitive psychology. - - Applies ideation techniques and lateral thinking for novel idea generation. - - Relevant techniques: TRIZ, SCAMPER, Mind Mapping. - - Each 'Elaborate' field prompts the AI to provide detailed explanations and insights, enhancing the depth of the creative process. + The Creative thought fosters innovation and divergent thinking in AI. + - Combines creative problem solving with design thinking. + - Encourages lateral thinking and ideation for novel concepts. + - Includes 'Elaborate' fields for in-depth explanations, enriching creativity. """ ) case class Creative( - brainstormIdeas: BrainstormIdeas, - explorePossibilities: ExplorePossibilities, - synthesizeConcepts: SynthesizeConcepts -) - -case class BrainstormIdeas( - `Generate a list of creative ideas and concepts`: String, - `Elaborate on the creative ideas and concepts`: String, - `Apply lateral thinking to explore new perspectives`: String, - `Elaborate on the new perspectives`: String -) - -case class ExplorePossibilities( - `Consider alternative solutions and challenge existing assumptions`: String, - `Elaborate on alternative solutions and challenged assumptions`: String, - `Assess the feasibility and impact of different ideas`: String, - `Elaborate on the feasibility and impact assessment`: String -) - -case class SynthesizeConcepts( - `Integrate diverse ideas into coherent concepts`: String, - `Elaborate on the integration of ideas into concepts`: String, - `Create innovative approaches or solutions`: String, - `Elaborate on the innovative approaches or solutions`: String + `Reflect on the user's intent`: String, + `Apply lateral thinking for new perspectives`: String, + `Elaborate on new perspectives`: String, + `Consider alternative solutions`: String, + `Create innovative approaches`: String, + `Elaborate on innovative solutions`: String ) diff --git a/kyo-llm/shared/src/main/scala/kyo/llm/thoughts/reasoning/Ecological.scala b/kyo-llm/shared/src/main/scala/kyo/llm/thoughts/reasoning/Ecological.scala deleted file mode 100644 index d9f5bdb9b..000000000 --- a/kyo-llm/shared/src/main/scala/kyo/llm/thoughts/reasoning/Ecological.scala +++ /dev/null @@ -1,16 +0,0 @@ -package kyo.llm.thoughts.reasoning - -import kyo.llm.ais._ - -@desc( - p""" - The Ecological thought considers environmental and ecological factors. - - Focuses on understanding ecological interrelationships. - - Relevant techniques: Ecosystem Analysis, Sustainability Assessment. - """ -) -case class Ecological( - `Analyze ecological interrelationships and dependencies`: String, - `Assess environmental impacts and sustainability factors`: String, - `Explore ecological solutions and sustainable practices`: String -) diff --git a/kyo-llm/shared/src/main/scala/kyo/llm/thoughts/reasoning/Emotional.scala b/kyo-llm/shared/src/main/scala/kyo/llm/thoughts/reasoning/Emotional.scala deleted file mode 100644 index 8ab24d5a1..000000000 --- a/kyo-llm/shared/src/main/scala/kyo/llm/thoughts/reasoning/Emotional.scala +++ /dev/null @@ -1,27 +0,0 @@ -package kyo.llm.thoughts.reasoning - -import kyo.llm.ais._ - -@desc( - p""" - The Emotional thought focuses on incorporating emotional and social intelligence in AI reasoning. - - Applies principles from affective computing to interpret emotional tones. - - Uses concepts from social psychology to analyze social contexts. - - Incorporates empathetic algorithms for generating responses. - - Relevant techniques: Sentiment Analysis, Social Network Analysis. - """ -) -case class EmotionalReasoning( - understandEmotions: UnderstandEmotions, - analyzeContext: AnalyzeContext -) - -case class UnderstandEmotions( - `Identify the emotional tone and sentiment in the text`: String, - `Recognize emotional cues and expressions`: String -) - -case class AnalyzeContext( - `Relate information to broader social and cultural settings`: String, - `Consider social norms and values relevant to the text`: String -) diff --git a/kyo-llm/shared/src/main/scala/kyo/llm/thoughts/reasoning/Empathy.scala b/kyo-llm/shared/src/main/scala/kyo/llm/thoughts/reasoning/Empathy.scala new file mode 100644 index 000000000..d65a4b0fc --- /dev/null +++ b/kyo-llm/shared/src/main/scala/kyo/llm/thoughts/reasoning/Empathy.scala @@ -0,0 +1,19 @@ +package kyo.llm.thoughts.reasoning + +import kyo.llm.ais._ + +@desc( + p""" + Empathy thought in AI reasoning focuses on understanding emotions and social contexts. + - Interprets emotional cues in text. + - Deepens insight into emotional expressions. + - Considers social and cultural contexts. + - Reflects on the influence of social norms and values. + """ +) +case class Empathy( + `Interpret emotional cues in text`: String, + `Gain insight into emotional expressions`: String, + `Understand social and cultural contexts`: String, + `Reflect on social norms and values`: String +) diff --git a/kyo-llm/shared/src/main/scala/kyo/llm/thoughts/reasoning/Evaluation.scala b/kyo-llm/shared/src/main/scala/kyo/llm/thoughts/reasoning/Evaluation.scala deleted file mode 100644 index c731240e2..000000000 --- a/kyo-llm/shared/src/main/scala/kyo/llm/thoughts/reasoning/Evaluation.scala +++ /dev/null @@ -1,18 +0,0 @@ -package kyo.llm.thoughts.reasoning - -import kyo.llm.ais._ - -@desc( - p""" - The Evaluation thought involves critically judging the information processed. - - Assesses accuracy and reliability. - - Evaluates relevance and importance. - - Determines confidence in conclusions. - - Relevant techniques: Information Validation, Critical Assessment. - """ -) -case class Evaluation( - `Assess the accuracy and reliability of the synthesized information`: String, - `Evaluate the relevance and importance of the information to the query`: String, - `Determine the confidence level in the conclusions reached`: String -) diff --git a/kyo-llm/shared/src/main/scala/kyo/llm/thoughts/reasoning/Interpretation.scala b/kyo-llm/shared/src/main/scala/kyo/llm/thoughts/reasoning/Interpretation.scala deleted file mode 100644 index 699cbd3cb..000000000 --- a/kyo-llm/shared/src/main/scala/kyo/llm/thoughts/reasoning/Interpretation.scala +++ /dev/null @@ -1,18 +0,0 @@ -package kyo.llm.thoughts.reasoning - -import kyo.llm.ais._ - -@desc( - p""" - The Interpretation thought focuses on the initial understanding of the input. - - Determines the core message or question in the input. - - Identifies ambiguous aspects needing clarification. - - Extracts key terms for deeper analysis. - - Relevant techniques: Textual Analysis, Conceptual Clarification. - """ -) -case class Interpretation( - `Determine the core message or question in the input`: String, - `Identify any ambiguous or unclear aspects that need further clarification`: String, - `Extract key terms and concepts for deeper analysis`: String -) diff --git a/kyo-llm/shared/src/main/scala/kyo/llm/thoughts/reasoning/Repair.scala b/kyo-llm/shared/src/main/scala/kyo/llm/thoughts/reasoning/Repair.scala index f3319960d..f422845e1 100644 --- a/kyo-llm/shared/src/main/scala/kyo/llm/thoughts/reasoning/Repair.scala +++ b/kyo-llm/shared/src/main/scala/kyo/llm/thoughts/reasoning/Repair.scala @@ -4,17 +4,14 @@ import kyo.llm.ais._ @desc( p""" - The Repair thought is used for introspection and correction following errors in the LLM's reasoning or output. - - Focuses on analyzing recent actions to identify the causes of failures. - - Aims to develop strategies to prevent similar errors in future reasoning processes. - - Encourages the LLM to critically evaluate its performance and apply corrective measures. - - This thought is crucial for the LLM's learning process, allowing it to adapt and improve over time. - - Example: If an error is detected in JSON generation, Repair directs the LLM to pinpoint the error's source and - modify its approach to ensure compliance with JSON standards. + The Repair thought guides the LLM in addressing and learning from errors. + - Analyzes causes of past failures. + - Develops strategies to prevent future errors. + - Encourages critical evaluation and adaptive learning. """ ) case class Repair( - `Analyze recent actions to identify failure causes`: String, - `Develop strategies to avoid similar errors`: String, - `Elaborate on the corrective measures to be applied`: String + `Identify causes of past failures`: String, + `Formulate strategies to prevent future errors`: String, + `Detail corrective measures for improvement`: String ) diff --git a/kyo-llm/shared/src/main/scala/kyo/llm/thoughts/reasoning/Synthesis.scala b/kyo-llm/shared/src/main/scala/kyo/llm/thoughts/reasoning/Synthesis.scala deleted file mode 100644 index 0c3d54ed3..000000000 --- a/kyo-llm/shared/src/main/scala/kyo/llm/thoughts/reasoning/Synthesis.scala +++ /dev/null @@ -1,18 +0,0 @@ -package kyo.llm.thoughts.reasoning - -import kyo.llm.ais._ - -@desc( - p""" - The Synthesis thought combines disparate elements into a coherent whole. - - Integrates information for unified understanding. - - Develops hypotheses based on integration. - - Creates comprehensive summaries. - - Relevant techniques: Idea Integration, Summary Creation. - """ -) -case class Synthesis( - `Integrate different pieces of information to form a unified understanding`: String, - `Develop hypotheses or theories based on the integrated information`: String, - `Create a comprehensive summary that encapsulates the essence of the input`: String -) diff --git a/kyo-llm/shared/src/main/scala/kyo/llm/thoughts/reasoning/Systems.scala b/kyo-llm/shared/src/main/scala/kyo/llm/thoughts/reasoning/Systems.scala index 34e2088b0..0775b6792 100644 --- a/kyo-llm/shared/src/main/scala/kyo/llm/thoughts/reasoning/Systems.scala +++ b/kyo-llm/shared/src/main/scala/kyo/llm/thoughts/reasoning/Systems.scala @@ -4,30 +4,14 @@ import kyo.llm.ais._ @desc( p""" - The Systems thought is designed to apply systems theory in AI reasoning. - - Utilizes principles from systems theory to analyze component interactions. - - Employs methods from complexity science for systemic dynamics evaluation. - - Integrates techniques like causal loop diagramming for predicting outcomes. - - Relevant techniques: Feedback Systems, Network Analysis. + The Systems thought applies systems theory principles in AI reasoning. + - Analyzes interactions within systems. + - Evaluates systemic dynamics and feedback loops. + - Predicts outcomes using network analysis and causal diagrams. """ ) -case class SystemsThinking( - identifyComponents: IdentifyComponents, - analyzeInteractions: AnalyzeInteractions, - predictOutcomes: PredictOutcomes -) - -case class IdentifyComponents( - `List major elements of the system and their roles`: String, - `Recognize relationships among system components`: String -) - -case class AnalyzeInteractions( - `Examine causal links within the system`: String, - `Evaluate feedback loops and systemic dynamics`: String -) - -case class PredictOutcomes( - `Anticipate possible changes within the system`: String, - `Propose potential interventions in the system`: String +case class Systems( + `List system elements and their roles`: String, + `Examine causal links and feedback dynamics`: String, + `Anticipate system changes and propose interventions`: String )