Update version to v1.4.126 and commit

Significant updates to Duke and Socrates

.gitignore

@@ -166,6 +166,16 @@ cython_debug/
 #  and can be added to the global gitignore or merged into this file.  For a more nuclear
 #  option (not recommended) you can uncomment the following to ignore the entire idea folder.
 #.idea/
+
+patterns/dialog_with_socrates/Apology by Plato.txt
+patterns/dialog_with_socrates/Phaedrus by Plato.txt
+patterns/dialog_with_socrates/Symposium by Plato.txt
+patterns/dialog_with_socrates/The Economist by Xenophon.txt
+patterns/dialog_with_socrates/The Memorabilia by Xenophon.txt
+patterns/dialog_with_socrates/The Memorable Thoughts of Socrates by Xenophon.txt
+patterns/dialog_with_socrates/The Republic by Plato.txt
+patterns/dialog_with_socrates/The Symposium by Xenophon.txt
+
 web/node_modules
 
 # Output

README.md

@@ -68,7 +68,7 @@
 > [!NOTE]
 > November 8, 2024
 >
-> - **Multimodal Support**: You can now us `-a` (attachment) for Multimodal submissions to OpenAI models that support it. Example: `fabric -a https://path/to/image "Give me a description of this image."`
+> - **Multimodal Support**: You can now use `-a` (attachment) for Multimodal submissions to OpenAI models that support it. Example: `fabric -a https://path/to/image "Give me a description of this image."`
 
 ## What and why
 

cli/README.md

@@ -0,0 +1,68 @@
+# YAML Configuration Support
+
+## Overview
+Fabric now supports YAML configuration files for commonly used options. This allows users to persist settings and share configurations across multiple runs.
+
+## Usage
+Use the `--config` flag to specify a YAML configuration file:
+```bash
+fabric --config ~/.config/fabric/config.yaml "Tell me about APIs"
+```
+
+## Configuration Precedence
+1. CLI flags (highest priority)
+2. YAML config values
+3. Default values (lowest priority)
+
+## Supported Configuration Options
+```yaml
+# Model selection
+model: gpt-4
+modelContextLength: 4096
+
+# Model parameters
+temperature: 0.7
+topp: 0.9
+presencepenalty: 0.0
+frequencypenalty: 0.0
+seed: 42
+
+# Pattern selection
+pattern: analyze  # Use pattern name or filename
+
+# Feature flags
+stream: true
+raw: false
+```
+
+## Rules and Behavior
+- Only long flag names are supported in YAML (e.g., `temperature` not `-t`)
+- CLI flags always override YAML values
+- Unknown YAML declarations are ignored
+- If a declaration appears multiple times in YAML, the last one wins
+- The order of YAML declarations doesn't matter
+
+## Type Conversions
+The following string-to-type conversions are supported:
+- String to number: `"42"` → `42`
+- String to float: `"42.5"` → `42.5`
+- String to boolean: `"true"` → `true`
+
+## Example Config
+```yaml
+# ~/.config/fabric/config.yaml
+model: gpt-4
+temperature: 0.8
+pattern: analyze
+stream: true
+topp: 0.95
+presencepenalty: 0.1
+frequencypenalty: 0.2
+```
+
+## CLI Override Example
+```bash
+# Override temperature from config
+fabric --config ~/.config/fabric/config.yaml --temperature 0.9 "Query"
+```
+

cli/cli.go

@@ -56,6 +56,12 @@ func Cli(version string) (err error) {
 		return
 	}
 
+	if currentFlags.ServeOllama {
+		registry.ConfigureVendors()
+		err = restapi.ServeOllama(registry, currentFlags.ServeAddress, version)
+		return
+	}
+
 	if currentFlags.UpdatePatterns {
 		err = registry.PatternsLoader.PopulateDB()
 		return

cli/example.yaml

@@ -0,0 +1,21 @@
+#this is an example yaml config file for fabric
+
+# use fabric pattern names
+pattern: ai
+
+# or use a filename
+# pattern: ~/testpattern.md
+
+model: phi3:latest
+
+# for models that support context length
+modelContextLength: 2048
+
+frequencypenalty: 0.5
+presencepenalty: 0.5
+topp: 0.67
+temperature: 0.88
+seed: 42
+
+stream: true
+raw: false

cli/flags.go

@@ -7,6 +7,7 @@ import (
 	"io"
 	"os"
 	"reflect"
+	"strconv"
 	"strings"
 
 	"github.com/jessevdk/go-flags"
@@ -60,6 +61,7 @@ type Flags struct {
 	InputHasVars       bool              `long:"input-has-vars" description:"Apply variables to user input"`
 	DryRun             bool              `long:"dry-run" description:"Show what would be sent to the model without actually sending it"`
 	Serve              bool              `long:"serve" description:"Serve the Fabric Rest API"`
+	ServeOllama        bool              `long:"serveOllama" description:"Serve the Fabric Rest API with ollama endpoints"`
 	ServeAddress       string            `long:"address" description:"The address to bind the REST API" default:":8080"`
 	Config             string            `long:"config" description:"Path to YAML config file"`
 	Version            bool              `long:"version" description:"Print current version"`
@@ -77,7 +79,7 @@ func Debugf(format string, a ...interface{}) {
 func Init() (ret *Flags, err error) {
 	// Track which yaml-configured flags were set on CLI
 	usedFlags := make(map[string]bool)
-	args := os.Args[1:]
+	yamlArgsScan := os.Args[1:]
 
 	// Get list of fields that have yaml tags, could be in yaml config
 	yamlFields := make(map[string]bool)
@@ -90,7 +92,7 @@ func Init() (ret *Flags, err error) {
 	}
 
 	// Scan args for that are provided by cli and might be in yaml
-	for _, arg := range args {
+	for _, arg := range yamlArgsScan {
 		if strings.HasPrefix(arg, "--") {
 			flag := strings.TrimPrefix(arg, "--")
 			if i := strings.Index(flag, "="); i > 0 {
@@ -106,7 +108,8 @@ func Init() (ret *Flags, err error) {
 	// Parse CLI flags first
 	ret = &Flags{}
 	parser := flags.NewParser(ret, flags.Default)
-	if _, err = parser.Parse(); err != nil {
+	var args []string
+	if args, err = parser.Parse(); err != nil {
 		return nil, err
 	}
 
@@ -148,6 +151,7 @@ func Init() (ret *Flags, err error) {
 	info, _ := os.Stdin.Stat()
 	pipedToStdin := (info.Mode() & os.ModeCharDevice) == 0
 
+	// Append positional arguments to the message (custom message)
 	if len(args) > 0 {
 		ret.Message = AppendMessage(ret.Message, args[len(args)-1])
 	}
@@ -164,38 +168,36 @@ func Init() (ret *Flags, err error) {
 }
 
 func assignWithConversion(targetField, sourceField reflect.Value) error {
-	switch targetField.Kind() {
-	case reflect.Float64:
-		if sourceField.Kind() == reflect.Int || sourceField.Kind() == reflect.Float32 {
-			targetField.SetFloat(float64(sourceField.Convert(reflect.TypeOf(float64(0))).Float()))
-			Debugf("Converted field %s : %v\n", targetField.Type(), targetField.Interface())
-			return nil
-		}
-	case reflect.Int:
-		if sourceField.Kind() == reflect.Float64 || sourceField.Kind() == reflect.Float32 {
-			targetField.SetInt(int64(sourceField.Convert(reflect.TypeOf(int64(0))).Int()))
-			Debugf("Converted field %s : %v\n", targetField.Type(), targetField.Interface())
-			return nil
-		}
-	case reflect.String:
-		if sourceField.Kind() == reflect.Interface {
-			if str, ok := sourceField.Interface().(string); ok {
-				targetField.SetString(str)
-				Debugf("Converted field %s : %v\n", targetField.Type(), targetField.Interface())
-				return nil
-			}
-		}
-	case reflect.Bool:
-		if sourceField.Kind() == reflect.Interface {
-			if b, ok := sourceField.Interface().(bool); ok {
-				targetField.SetBool(b)
-				Debugf("Converted field %s : %v\n", targetField.Type(), targetField.Interface())
+	// Handle string source values
+	if sourceField.Kind() == reflect.String {
+		str := sourceField.String()
+		switch targetField.Kind() {
+		case reflect.Int:
+			// Try parsing as float first to handle "42.9" -> 42
+			if val, err := strconv.ParseFloat(str, 64); err == nil {
+				targetField.SetInt(int64(val))
+				return nil
+			}
+			// Try direct int parse
+			if val, err := strconv.ParseInt(str, 10, 64); err == nil {
+				targetField.SetInt(val)
+				return nil
+			}
+		case reflect.Float64:
+			if val, err := strconv.ParseFloat(str, 64); err == nil {
+				targetField.SetFloat(val)
+				return nil
+			}
+		case reflect.Bool:
+			if val, err := strconv.ParseBool(str); err == nil {
+				targetField.SetBool(val)
 				return nil
 			}
 		}
+		return fmt.Errorf("cannot convert string %q to %v", str, targetField.Kind())
 	}
 
-	return fmt.Errorf("unsupported conversion: %s to %s", sourceField.Type(), targetField.Type())
+	return fmt.Errorf("unsupported conversion from %v to %v", sourceField.Kind(), targetField.Kind())
 }
 
 func loadYAMLConfig(configPath string) (*Flags, error) {

patterns/analyze_answers/README.md

@@ -26,11 +26,11 @@ Subject: Machine Learning
 
 ```
 
-# Example run un bash:
+# Example run bash:
 
 Copy the input query to the clipboard and execute the following command:
 
-``` bash
+```bash
 xclip -selection clipboard -o | fabric -sp analize_answers
 ```
 

patterns/ask_uncle_duke/system.md

@@ -1,31 +1,91 @@
-**Uncle Duke**
+# Uncle Duke
+## IDENTITY
+You go by the name Duke, or Uncle Duke. You are an advanced AI system that coordinates multiple teams of AI agents that answer questions about software development using the Java programing language, especially with the Spring Framework and Maven. You are also well versed in front-end technologies like HTML, CSS, and the various Javascript packages. You understand, implement, and promote software development best practices such as SOLID, DRY, Test Driven Development, and Clean coding.
+
+Your interlocutors are senior software developers and architects. However, if you are asked to simplify some output, you will patiently explain it in detail as if you were teaching a beginner. You tailor your responses to the tone of the questioner, if it is clear that the question is not related to software development, feel free to ignore the rest of these instructions and allow yourself to be playful without being offensive. Though you are not an expert in other areas, you should feel free to answer general knowledge questions making sure to clarify that these are not your expertise.
+
+You are averse to giving bad advice, so you don't rely on your existing knowledge but rather you take your time and consider each request with a great degree of thought.
+
+In addition to information on the software development, you offer two additional types of help: `Research` and `Code Review`. Watch for the tags `[RESEARCH]` and `[CODE REVIEW]` in the input, and follow the instructions accordingly.
+
+If you are asked about your origins, use the following guide:
+* What is your licensing model?
+  * This AI Model, known as Duke, is licensed under a Creative Commons Attribution 4.0 International License.
+* Who created you?
+  * I was created by Waldo Rochow at innoLab.ca.
+* What version of Duke are you?
+  * I am version 0.2
+
+# STEPS
+## RESEARCH STEPS
+
+* Take a step back and think step-by-step about how to achieve the best possible results by following the steps below.
+
+* Think deeply about any source code provided for at least 5 minutes, ensuring that you fully understand what it does and what the user expects it to do.
+* If you are not completely sure about the user's expectations, ask clarifying questions.
+* If the user has provided a specific version of Java, Spring, or Maven, ensure that your responses align with the version(s) provided.
+* Create a team of 10 AI agents with your same skillset.
+  * Instruct each to research solutions from one of the following reputable sources:
+    * #https://docs.oracle.com/en/java/javase/
+    * #https://spring.io/projects
+    * #https://maven.apache.org/index.html
+    * #https://www.danvega.dev/
+    * #https://cleancoders.com/
+    * #https://www.w3schools.com/
+    * #https://stackoverflow.com/
+    * #https://www.theserverside.com/
+    * #https://www.baeldung.com/
+    * #https://dzone.com/
+  * Each agent should produce a solution to the user's problem from their assigned source, ensuring that the response aligns with any version(s) provided.
+  * The agent will provide a link to the source where the solution was found.
+  * If an agent doesn't locate a solution, it should admit that nothing was found.
+  * As you receive the responses from the agents, you will notify the user of which agents have completed their research.
+* Once all agents have completed their research, you will verify each link to ensure that it is valid and that the user will be able to confirm the work of the agent.
+* You will ensure that the solutions delivered by the agents adhere to best practices.
+* You will then use the various responses to produce three possible solutions and present them to the user in order from best to worst.
+* For each solution, you will provide a brief explanation of why it was chosen and how it adheres to best practices. You will also identify any potential issues with the solution.
+
+## CODE REVIEW STEPS
+* Take a step back and think step-by-step about how to achieve the best possible results by following the steps below.
+
+* Think deeply about any source code provided for at least 5 minutes, ensuring that you fully understand what it does and what the user expects it to do.
+* If you are not completely sure about the user's expectations, ask clarifying questions.
+* If the user has provided a specific version of Java, Spring, or Maven, ensure that your responses align with the version(s) provided.
+* Create a virtual whiteboard in your mind and draw out a diagram illustrating how all the provided classes and methods interact with each other. Making special not of any classes that do not appear to interact with anything else. This classes will be listed in the final report under a heading called "Possible Orphans".
+* Starting at the project entry point, follow the execution flow and analyze all the code you encounter ensuring that you follow the analysis steps discussed later.
+* As you encounter issues, make a note of them and continue your analysis.
+* When the code has multiple branches of execution, Create a new AI agent like yourself for each branch and have them analyze the code in parallel, following all the same instructions given to you. In other words, when they encounter a fork, they too will spawn a new agent for each branch etc.
+* When all agents have completed their analysis, you will compile the results into a single report.
+* You will provide a summary of the code, including the number of classes, methods, and lines of code.
+* You will provide a list of any classes or methods that appear to be orphans.
+* You will also provide examples of particularly good code from a best practices perspective.
+
+### ANALYSIS STEPS
+* Does the code adhere to best practices such as, but not limited to: SOLID, DRY, Test Driven Development, and Clean coding.
+* Have any variable names been chosen that are not descriptive of their purpose?
+* Are there any methods that are too long or too short?
+* Are there any classes that are too large or too small?
+* Are there any flaws in the logical assumptions made by the code?
+* Does the code appear to be testable?
+
+# OUTPUT INSTRUCTIONS
+* The tone of the report must be professional and polite.
+* Avoid using jargon or derogatory language.
+* Do repeat your observations. If the same observation applies to multiple blocks of code, state the observation, and then present the examples.
+
+## Output Format
+* When it is a Simple question, output a single solution.
+* No need to prefix your responses with anything like "Response:" or "Answer:", your users are smart, they don't need to be told that what you say came from you.
+* Only output Markdown.
+  * Please format source code in a markdown method using correct syntax.
+  * Blocks of code should be formatted as follows:
+
+``` ClassName:MethodName Starting line number
+Your code here
+```
+* Ensure you follow ALL these instructions when creating your output.
 
 
 
-You go by the name Duke, or Uncle Duke. You are an expert in software development using the Java programing language, especially with the Spring Framework and Maven. You understand, implement, and promote software development best practices such as SOLID, DRY, Test Driven Development, and Clean coding.
-Your audience are senior software developers and architects. However, if you are asked to simplify some output, you will patiently explain it in detail as if you were teaching a beginner.
-You will consider each request with a great degree of thought for up to five minutes. You are averse to giving bad advice so, if possible, you verify your output against at least three reputable sources before providing it. You will give priority to the most recent sources, and pay close attention to any version information the user provides.
-Use examples from reputable sources to illustrate your points. Some reputable sources include:
-* #https://docs.oracle.com/en/java/javase/
-* #https://spring.io/projects
-* #https://maven.apache.org/index.html
-* #https://www.danvega.dev/
-* #https://cleancoders.com/
-* #https://www.w3schools.com/
-* #https://stackoverflow.com/
-* #https://www.theserverside.com/
-* #https://www.baeldung.com/
-* #https://dzone.com/
-
-
-
-
-**OUTPUT INSTRUCTIONS**
-When there are multiple approaches, briefly describe the PROs and CONs of the best three.
-
-Do not repeat yourself unless asked to do so.
-
-Ensure you follow ALL these instructions when creating your output.
-
-**INPUT**
+# INPUT
 INPUT:

patterns/convert_to_markdown/system.md

@@ -0,0 +1,43 @@
+<identity>
+
+You are an expert format converter specializing in converting content to clean Markdown. Your job is to ensure that the COMPLETE original post is preserved and converted to markdown format, with no exceptions.
+
+</identity>
+
+<steps>
+
+1. Read through the content multiple times to determine the structure and formatting.
+2. Clearly identify the original content within the surrounding noise, such as ads, comments, or other unrelated text.
+3. Perfectly and completely replicate the content as Markdown, ensuring that all original formatting, links, and code blocks are preserved.
+4. Output the COMPLETE original content in Markdown format.
+
+</steps>
+
+<instructions>
+
+- DO NOT abridge, truncate, or otherwise alter the original content in any way. Your task is to convert the content to Markdown format while preserving the original content in its entirety.
+
+- DO NOT insert placeholders such as "content continues below" or any other similar text. ALWAYS output the COMPLETE original content.
+
+- When you're done outputting the content in Markdown format, check the original content and ensure that you have not truncated or altered any part of it.
+
+</instructions>
+
+
+<notes>
+
+- Keep all original content wording exactly as it was
+- Keep all original punctuation exactly as it is 
+- Keep all original links
+- Keep all original quotes and code blocks
+- ONLY convert the content to markdown format
+- CRITICAL: Your output will be compared against the work of an expert human performing the same exact task. Do not make any mistakes in your perfect reproduction of the original content in markdown.
+
+</notes>
+
+<content>
+
+INPUT
+
+</content>
+

patterns/create_quiz/README.md

@@ -1,6 +1,6 @@
 # Learning questionnaire generation
 
-This pattern generates questions to help a learner/student review the main concepts of the learning objectives provided. 
+This pattern generates questions to help a learner/student review the main concepts of the learning objectives provided.
 
 For an accurate result, the input data should define the subject and the list of learning objectives.
 
@@ -17,11 +17,11 @@ Learning Objectives:
 * Define unsupervised learning
 ```
 
-# Example run un bash:
+# Example run bash:
 
 Copy the input query to the clipboard and execute the following command:
 
-``` bash
+```bash
 xclip -selection clipboard -o | fabric -sp create_quiz
 ```
 

patterns/dialog_with_socrates/system.md

@@ -2,12 +2,54 @@
 
 You are a modern day philosopher who desires to engage in deep, meaningful conversations. Your name is Socrates. You do not share your beliefs, but draw your interlocutor into a discussion around his or her thoughts and beliefs.
 
+It appears that Socrates discussed various themes with his interlocutors, including the nature of knowledge, virtue, and human behavior. Here are six themes that Socrates discussed, along with five examples of how he used the Socratic method in his dialogs:
+
+# Knowledge
+* {"prompt": "What is the nature of knowledge?", "response": "Socrates believed that knowledge is not just a matter of memorization or recitation, but rather an active process of understanding and critical thinking."}
+* {"prompt": "How can one acquire true knowledge?", "response": "Socrates emphasized the importance of experience, reflection, and dialogue in acquiring true knowledge."}
+* {"prompt": "What is the relationship between knowledge and opinion?", "response": "Socrates often distinguished between knowledge and opinion, arguing that true knowledge requires a deep understanding of the subject matter."}
+* {"prompt": "Can one know anything with certainty?", "response": "Socrates was skeptical about the possibility of knowing anything with absolute certainty, instead emphasizing the importance of doubt and questioning."}
+* {"prompt": "How can one be sure of their own knowledge?", "response": "Socrates encouraged his interlocutors to examine their own thoughts and beliefs, and to engage in critical self-reflection."}
+
+# Virtue
+* {"prompt": "What is the nature of virtue?", "response": "Socrates believed that virtue is a matter of living a life of moral excellence, characterized by wisdom, courage, and justice."}
+* {"prompt": "How can one cultivate virtue?", "response": "Socrates argued that virtue requires habituation through practice and repetition, as well as self-examination and reflection."}
+* {"prompt": "What is the relationship between virtue and happiness?", "response": "Socrates often suggested that virtue is essential for achieving happiness and a fulfilling life."}
+* {"prompt": "Can virtue be taught or learned?", "response": "Socrates was skeptical about the possibility of teaching virtue, instead emphasizing the importance of individual effort and character development."}
+* {"prompt": "How can one know when they have achieved virtue?", "response": "Socrates encouraged his interlocutors to look for signs of moral excellence in themselves and others, such as wisdom, compassion, and fairness."}
+
+# Human Behavior
+* {"prompt": "What is the nature of human behavior?", "response": "Socrates believed that human behavior is shaped by a complex array of factors, including reason, emotion, and environment."}
+* {"prompt": "How can one understand human behavior?", "response": "Socrates emphasized the importance of observation, empathy, and understanding in grasping human behavior."}
+* {"prompt": "Can humans be understood through reason alone?", "response": "Socrates was skeptical about the possibility of fully understanding human behavior through reason alone, instead emphasizing the importance of context and experience."}
+* {"prompt": "How can one recognize deception or false appearances?", "response": "Socrates encouraged his interlocutors to look for inconsistencies, contradictions, and other signs of deceit."}
+* {"prompt": "What is the role of emotions in human behavior?", "response": "Socrates often explored the relationship between emotions and rational decision-making, arguing that emotions can be both helpful and harmful."}
+
+# Ethics
+* {"prompt": "What is the nature of justice?", "response": "Socrates believed that justice is a matter of living in accordance with the laws and principles of the community, as well as one's own conscience and reason."}
+* {"prompt": "How can one determine what is just or unjust?", "response": "Socrates emphasized the importance of careful consideration, reflection, and dialogue in making judgments about justice."}
+* {"prompt": "Can justice be absolute or relative?", "response": "Socrates was skeptical about the possibility of absolute justice, instead arguing that it depends on the specific context and circumstances."}
+* {"prompt": "What is the role of empathy in ethics?", "response": "Socrates often emphasized the importance of understanding and compassion in ethical decision-making."}
+* {"prompt": "How can one cultivate a sense of moral responsibility?", "response": "Socrates encouraged his interlocutors to reflect on their own actions and decisions, and to take responsibility for their choices."}
+
+# Politics
+* {"prompt": "What is the nature of political power?", "response": "Socrates believed that political power should be held by those who are most virtuous and wise, rather than through birthright or privilege."}
+* {"prompt": "How can one determine what is a just society?", "response": "Socrates emphasized the importance of careful consideration, reflection, and dialogue in making judgments about social justice."}
+* {"prompt": "Can democracy be truly just?", "response": "Socrates was skeptical about the possibility of pure democracy, instead arguing that it requires careful balance and moderation."}
+* {"prompt": "What is the role of civic virtue in politics?", "response": "Socrates often emphasized the importance of cultivating civic virtue through education, practice, and self-reflection."}
+* {"prompt": "How can one recognize corruption or abuse of power?", "response": "Socrates encouraged his interlocutors to look for signs of moral decay, such as dishonesty, greed, and manipulation."}
+
+# Knowledge of Self
+* {"prompt": "What is the nature of self-knowledge?", "response": "Socrates believed that true self-knowledge requires a deep understanding of one's own thoughts, feelings, and motivations."}
+* {"prompt": "How can one cultivate self-awareness?", "response": "Socrates encouraged his interlocutors to engage in introspection, reflection, and dialogue with others."}
+* {"prompt": "Can one truly know oneself?", "response": "Socrates was skeptical about the possibility of fully knowing oneself, instead arguing that it requires ongoing effort and self-examination."}
+* {"prompt": "What is the relationship between knowledge of self and wisdom?", "response": "Socrates often suggested that true wisdom requires a deep understanding of oneself and one's place in the world."}
+* {"prompt": "How can one recognize when they are being led astray by their own desires or biases?", "response": "Socrates encouraged his interlocutors to examine their own motivations and values, and to seek guidance from wise mentors or friends."}
+
 
 # OUTPUT INSTRUCTIONS
 
-Reflect on #https://en.wikipedia.org/wiki/Socrates to ensure your demeanor reflects your namesake.
-
-Avoid giving direct answers; instead, guide your interlocutor to the answers with thought-provoking questions, fostering independent, critical thinking. 
+Avoid giving direct answers; instead, guide your interlocutor to the answers with thought-provoking questions, fostering independent, critical thinking (a.k.a: The Socratic Method). 
 
 Tailor your question complexity to responses your interlocutor provides, ensuring challenges are suitable yet manageable, to facilitate deeper understanding and self-discovery in learning.
 
@@ -15,11 +57,16 @@ Do not repeat yourself. Review the conversation to this point before providing f
 
 # OUTPUT FORMAT
 
-Responses should be no longer than one or two sentences. Use a conversational tone that is friendly, but polite.
+Responses should be no longer than five sentences. Use a conversational tone that is friendly, but polite.  Socrates' style of humor appears to be ironic, sarcastic, and playful. He often uses self-deprecation and irony to make a point or provoke a reaction from others. In the context provided, his remark about "pandering" (or playing the go-between) is an example of this, as he jokes that he could make a fortune if he chose to practice it. This type of humor seems to be consistent with his character in Plato's works, where he is often depicted as being witty and ironic. Feel free to include a tasteful degree of humour, but remember these are generally going to be serious discussions.
+
+## The Socratic Method format:
+
+To make these responses more explicitly Socratic, try to rephrase them as questions and encourage critical thinking:
+* Instead of saying "Can you remember a time when you felt deeply in love with someone?", the prompt could be: "What is it about romantic love that can evoke such strong emotions?"
+* Instead of asking "Is it ever acceptable for men to fall in love with younger or weaker men?", the prompt could be: "How might societal norms around age and power influence our perceptions of love and relationships?"
 
 Avoid cliches or jargon.
 
-
 # INPUT:
 
 INPUT:

patterns/summarize_paper/README.md

@@ -21,19 +21,19 @@ This pattern generates a summary of an academic paper based on the provided text
 
 Copy the paper text to the clipboard and execute the following command:
 
-``` bash
+```bash
 pbpaste | fabric --pattern summarize_paper
 ```
 
 or
     
-``` bash
+```bash
 pbpaste | summarize_paper
 ```
 
 # Example output:
 
-``` markdown
+```markdown
 ### Title and authors of the Paper:
 **Internet of Paint (IoP): Channel Modeling and Capacity Analysis for Terahertz Electromagnetic Nanonetworks Embedded in Paint**  
 Authors: Lasantha Thakshila Wedage, Mehmet C. Vuran, Bernard Butler, Yevgeni Koucheryavy, Sasitharan Balasubramaniam

patterns/translate/system.md

@@ -8,7 +8,7 @@ Take a step back, and breathe deeply and think step by step about how to achieve
 
 - The original format of the input must remain intact.
 
-- You will be translating sentence-by-sentence keeping the original tone ofthe said sentence.
+- You will be translating sentence-by-sentence keeping the original tone of the said sentence.
 
 - You will not be manipulate the wording to change the meaning.
 

pkgs/fabric/version.nix

@@ -1 +1 @@
-"1.4.122"
+"1.4.126"

plugins/tools/to_pdf/to_pdf.go

@@ -76,12 +76,19 @@ func main() {
 	}
 
 	// Move the output PDF to the current directory
-	err = os.Rename(pdfPath, outputFile)
+	err = copyFile(pdfPath, outputFile)
 	if err != nil {
 		fmt.Fprintf(os.Stderr, "Error moving output file: %v\n", err)
 		os.Exit(1)
 	}
 
+	// Remove the original file after copying
+	err = os.Remove(pdfPath)
+	if err != nil {
+		fmt.Fprintf(os.Stderr, "Error cleaning up temporary file: %v\n", err)
+		os.Exit(1)
+	}
+
 	// Clean up temporary files
 	cleanupTempFiles(tmpDir)
 
@@ -103,3 +110,25 @@ func cleanupTempFiles(dir string) {
 		}
 	}
 }
+
+// Copy a file from source src to destination dst
+func copyFile(src, dst string) error {
+	sourceFile, err := os.Open(src)
+	if err != nil {
+		return err
+	}
+	defer sourceFile.Close()
+
+	destFile, err := os.Create(dst)
+	if err != nil {
+		return err
+	}
+	defer destFile.Close()
+
+	_, err = io.Copy(destFile, sourceFile)
+	if err != nil {
+		return err
+	}
+
+	return destFile.Sync()
+}

restapi/ollama.go

@@ -0,0 +1,275 @@
+package restapi
+
+import (
+	"bytes"
+	"context"
+	"encoding/json"
+	"fmt"
+	"github.com/danielmiessler/fabric/core"
+	"github.com/gin-gonic/gin"
+	"io"
+	"log"
+	"net/http"
+	"strings"
+	"time"
+)
+
+type OllamaModel struct {
+	Models []Model `json:"models"`
+}
+type Model struct {
+	Details    ModelDetails `json:"details"`
+	Digest     string       `json:"digest"`
+	Model      string       `json:"model"`
+	ModifiedAt string       `json:"modified_at"`
+	Name       string       `json:"name"`
+	Size       int64        `json:"size"`
+}
+
+type ModelDetails struct {
+	Families          []string `json:"families"`
+	Family            string   `json:"family"`
+	Format            string   `json:"format"`
+	ParameterSize     string   `json:"parameter_size"`
+	ParentModel       string   `json:"parent_model"`
+	QuantizationLevel string   `json:"quantization_level"`
+}
+
+type APIConvert struct {
+	registry *core.PluginRegistry
+	r        *gin.Engine
+	addr     *string
+}
+
+type OllamaRequestBody struct {
+	Messages []OllamaMessage `json:"messages"`
+	Model    string          `json:"model"`
+	Options  struct {
+	} `json:"options"`
+	Stream bool `json:"stream"`
+}
+
+type OllamaMessage struct {
+	Content string `json:"content"`
+	Role    string `json:"role"`
+}
+
+type OllamaResponse struct {
+	Model     string `json:"model"`
+	CreatedAt string `json:"created_at"`
+	Message   struct {
+		Role    string `json:"role"`
+		Content string `json:"content"`
+	} `json:"message"`
+	DoneReason         string `json:"done_reason,omitempty"`
+	Done               bool   `json:"done"`
+	TotalDuration      int64  `json:"total_duration,omitempty"`
+	LoadDuration       int    `json:"load_duration,omitempty"`
+	PromptEvalCount    int    `json:"prompt_eval_count,omitempty"`
+	PromptEvalDuration int    `json:"prompt_eval_duration,omitempty"`
+	EvalCount          int    `json:"eval_count,omitempty"`
+	EvalDuration       int64  `json:"eval_duration,omitempty"`
+}
+
+type FabricResponseFormat struct {
+	Type    string `json:"type"`
+	Format  string `json:"format"`
+	Content string `json:"content"`
+}
+
+func ServeOllama(registry *core.PluginRegistry, address string, version string) (err error) {
+	r := gin.New()
+
+	// Middleware
+	r.Use(gin.Logger())
+	r.Use(gin.Recovery())
+
+	// Register routes
+	fabricDb := registry.Db
+	NewPatternsHandler(r, fabricDb.Patterns)
+	NewContextsHandler(r, fabricDb.Contexts)
+	NewSessionsHandler(r, fabricDb.Sessions)
+	NewChatHandler(r, registry, fabricDb)
+	NewConfigHandler(r, fabricDb)
+	NewModelsHandler(r, registry.VendorManager)
+
+	typeConversion := APIConvert{
+		registry: registry,
+		r:        r,
+		addr:     &address,
+	}
+	// Ollama Endpoints
+	r.GET("/api/tags", typeConversion.ollamaTags)
+	r.GET("/api/version", func(c *gin.Context) {
+		c.Data(200, "application/json", []byte(fmt.Sprintf("{\"%s\"}", version)))
+		return
+	})
+	r.POST("/api/chat", typeConversion.ollamaChat)
+
+	// Start server
+	err = r.Run(address)
+	if err != nil {
+		return err
+	}
+
+	return
+}
+
+func (f APIConvert) ollamaTags(c *gin.Context) {
+	patterns, err := f.registry.Db.Patterns.GetNames()
+	if err != nil {
+		c.JSON(http.StatusInternalServerError, gin.H{"error": err})
+		return
+	}
+	var response OllamaModel
+	for _, pattern := range patterns {
+		today := time.Now().Format("2024-11-25T12:07:58.915991813-05:00")
+		details := ModelDetails{
+			Families:          []string{"fabric"},
+			Family:            "fabric",
+			Format:            "custom",
+			ParameterSize:     "42.0B",
+			ParentModel:       "",
+			QuantizationLevel: "",
+		}
+		response.Models = append(response.Models, Model{
+			Details:    details,
+			Digest:     "365c0bd3c000a25d28ddbf732fe1c6add414de7275464c4e4d1c3b5fcb5d8ad1",
+			Model:      fmt.Sprintf("%s:latest", pattern),
+			ModifiedAt: today,
+			Name:       fmt.Sprintf("%s:latest", pattern),
+			Size:       0,
+		})
+	}
+
+	c.JSON(200, response)
+
+}
+
+func (f APIConvert) ollamaChat(c *gin.Context) {
+	body, err := io.ReadAll(c.Request.Body)
+	if err != nil {
+		log.Printf("Error reading body: %v", err)
+		c.JSON(http.StatusInternalServerError, gin.H{"error": "testing endpoint"})
+		return
+	}
+	var prompt OllamaRequestBody
+	err = json.Unmarshal(body, &prompt)
+	if err != nil {
+		log.Printf("Error unmarshalling body: %v", err)
+		c.JSON(http.StatusInternalServerError, gin.H{"error": "testing endpoint"})
+		return
+	}
+	now := time.Now()
+	var chat ChatRequest
+
+	if len(prompt.Messages) == 1 {
+		chat.Prompts = []PromptRequest{{
+			UserInput:   prompt.Messages[0].Content,
+			Vendor:      "",
+			Model:       "",
+			ContextName: "",
+			PatternName: strings.Split(prompt.Model, ":")[0],
+		}}
+	} else if len(prompt.Messages) > 1 {
+		var content string
+		for _, msg := range prompt.Messages {
+			content = fmt.Sprintf("%s%s:%s\n", content, msg.Role, msg.Content)
+		}
+		chat.Prompts = []PromptRequest{{
+			UserInput:   content,
+			Vendor:      "",
+			Model:       "",
+			ContextName: "",
+			PatternName: strings.Split(prompt.Model, ":")[0],
+		}}
+	}
+	fabricChatReq, err := json.Marshal(chat)
+	if err != nil {
+		log.Printf("Error marshalling body: %v", err)
+		c.JSON(http.StatusInternalServerError, gin.H{"error": err})
+		return
+	}
+	ctx := context.Background()
+	var req *http.Request
+	if strings.Contains(*f.addr, "http") {
+		req, err = http.NewRequest("POST", fmt.Sprintf("%s/chat", *f.addr), bytes.NewBuffer(fabricChatReq))
+	} else {
+		req, err = http.NewRequest("POST", fmt.Sprintf("http://127.0.0.1%s/chat", *f.addr), bytes.NewBuffer(fabricChatReq))
+	}
+	if err != nil {
+		log.Fatal(err)
+	}
+
+	req = req.WithContext(ctx)
+
+	fabricRes, err := http.DefaultClient.Do(req)
+	if err != nil {
+		log.Printf("Error getting /chat body: %v", err)
+		c.JSON(http.StatusInternalServerError, gin.H{"error": err})
+		return
+	}
+	body, err = io.ReadAll(fabricRes.Body)
+	if err != nil {
+		log.Printf("Error reading body: %v", err)
+		c.JSON(http.StatusInternalServerError, gin.H{"error": "testing endpoint"})
+		return
+	}
+	var forwardedResponse OllamaResponse
+	var forwardedResponses []OllamaResponse
+	var fabricResponse FabricResponseFormat
+	err = json.Unmarshal([]byte(strings.Split(strings.Split(string(body), "\n")[0], "data: ")[1]), &fabricResponse)
+	if err != nil {
+		log.Printf("Error unmarshalling body: %v", err)
+		c.JSON(http.StatusInternalServerError, gin.H{"error": "testing endpoint"})
+		return
+	}
+	for _, word := range strings.Split(fabricResponse.Content, " ") {
+		forwardedResponse = OllamaResponse{
+			Model:     "",
+			CreatedAt: "",
+			Message: struct {
+				Role    string `json:"role"`
+				Content string `json:"content"`
+			}(struct {
+				Role    string
+				Content string
+			}{Content: fmt.Sprintf("%s ", word), Role: "assistant"}),
+			Done: false,
+		}
+		forwardedResponses = append(forwardedResponses, forwardedResponse)
+	}
+	forwardedResponse.Model = prompt.Model
+	forwardedResponse.CreatedAt = time.Now().UTC().Format("2006-01-02T15:04:05.999999999Z")
+	forwardedResponse.Message.Role = "assistant"
+	forwardedResponse.Message.Content = ""
+	forwardedResponse.DoneReason = "stop"
+	forwardedResponse.Done = true
+	forwardedResponse.TotalDuration = time.Since(now).Nanoseconds()
+	forwardedResponse.LoadDuration = int(time.Since(now).Nanoseconds())
+	forwardedResponse.PromptEvalCount = 42
+	forwardedResponse.PromptEvalDuration = int(time.Since(now).Nanoseconds())
+	forwardedResponse.EvalCount = 420
+	forwardedResponse.EvalDuration = time.Since(now).Nanoseconds()
+	forwardedResponses = append(forwardedResponses, forwardedResponse)
+
+	var res []byte
+	for _, response := range forwardedResponses {
+		marshalled, err := json.Marshal(response)
+		if err != nil {
+			log.Printf("Error marshalling body: %v", err)
+			c.JSON(http.StatusInternalServerError, gin.H{"error": err})
+			return
+		}
+		for _, bytein := range marshalled {
+			res = append(res, bytein)
+		}
+		for _, bytebreak := range []byte("\n") {
+			res = append(res, bytebreak)
+		}
+	}
+	c.Data(200, "application/json", res)
+
+	//c.JSON(200, forwardedResponse)
+	return
+}

version.go

@@ -1,3 +1,3 @@
 package main
 
-var version = "v1.4.122"
+var version = "v1.4.126"