Compare commits

...

23 Commits

Author SHA1 Message Date
github-actions[bot]
31df56add8 Update version to v1.4.131 and commit 2025-01-30 00:50:21 +00:00
Eugen Eisler
0f8a403dba Merge pull request #1270 from wmahfoudh/adding-output-filename-support-to-to_pdf
Added output filename support for to_pdf
2025-01-30 01:49:25 +01:00
Eugen Eisler
8b33b9946e Merge pull request #1271 from wmahfoudh/adding-deepseek-support
Adding deepseek support
2025-01-30 01:48:10 +01:00
Walid
a77efada0e feat: Added Deepseek AI integration 2025-01-23 20:50:56 +04:00
Walid
3e8aaed268 Added output filename support for to_pdf 2025-01-23 19:25:18 +04:00
Eugen Eisler
c2fad4de80 Merge pull request #1258 from tuergeist/readme-patch-1
Minor README fix and additional Example
2025-01-18 19:35:42 +01:00
Christoph Becker
e558d535df doc: Add scrape URL example. Fix Example 4 2025-01-13 14:58:39 +01:00
Christoph Becker
1c05b37c76 doc: Custom patterns also work with Claude models 2025-01-13 14:18:41 +01:00
Eugen Eisler
e46c588b9c Merge pull request #1257 from jessefmoore/main
Create analyze_threat_report_cmds
2025-01-13 13:31:52 +01:00
Eugen Eisler
3bf6b7b000 Merge pull request #1256 from JOduMonT/patch-1
Update README.md
2025-01-13 12:02:25 +01:00
Daniel Miessler
82db18a8aa Updated conversion post. 2025-01-13 00:16:13 -08:00
Daniel Miessler
5a765bd8fc Adding markdown converter. 2025-01-12 23:34:25 -08:00
Daniel Miessler
339e1e6790 Updated prediction creator. 2025-01-12 21:38:21 -08:00
Daniel Miessler
a106e6de27 Updated predictor pattern. 2025-01-12 16:37:26 -08:00
Daniel Miessler
86eddbeb0a Added new prediction generator. 2025-01-12 13:34:18 -08:00
Jesse Moore
2daf0d90ce Create system.md
Create pattern to extract commands from videos and threat reports to obtain commands so pentesters or red teams or Threat hunters can use to either threat hunt or simulate the threat actor.
2025-01-12 09:48:28 -08:00
Jonathan DUMONT
03dfa03f46 Update README.md
## Change
1. Windows Command: Because actually curl does not exist natively on Windows
2. Syntax: Because like this; it makes the “click, cut and paste” easier
2025-01-12 13:55:37 +01:00
Eugen Eisler
92bbbfe88b Merge pull request #1247 from kevnk/update-suggest_pattern-user-prompt
Update suggest_pattern: refine summaries and add recently added patterns
2025-01-10 12:57:57 +01:00
Eugen Eisler
fb2dc00b9c Merge pull request #1252 from jeffmcjunkin/patch-1
Update README.md: Add PowerShell aliases
2025-01-10 12:57:00 +01:00
Eugen Eisler
0014a53c6e Merge pull request #1253 from abassel/fix/fix_few_typos
Fixed few typos that I could find
2025-01-10 12:56:25 +01:00
Alexandre Bassel
021d2738e4 Fixed few typos that I could find 2025-01-10 03:44:54 -03:00
Jeff McJunkin
f312ad0364 Update README.md: Add PowerShell aliases 2025-01-09 12:39:23 -08:00
Kevin Kirchner
02aa41e6aa Update summaries and add recently added patterns 2025-01-05 14:59:31 -06:00
21 changed files with 607 additions and 188 deletions

10
Alma.md
View File

@@ -14,7 +14,7 @@ Those will be changes, updates, or modifications to the direction of the company
Alma Security was started by Chris Meyers, who was previously at Sigma Systems as CTO and HPE as a senior security engineer.
He started the company becuase, "I saw a gap in the authentication market, where companies were only looking at one or two aspects of one's identity to do authentication. They we're looking at the whole picture and turning that into a continuous authentication story."
He started the company because, "I saw a gap in the authentication market, where companies were only looking at one or two aspects of one's identity to do authentication. They we're looking at the whole picture and turning that into a continuous authentication story."
## Company Mission
@@ -52,11 +52,13 @@ NOTE: Some goals are things like project rollouts which serve the higher goals.
## Security Team Goals
- SG1: Secure all customer data -- especially biometric -- from security and privacy incidents.
- SG2: Protect Alma Security's intellectual property from being captured by unathorized parties.
- SG2: Protect Alma Security's intellectual property from being captured by unauthorized parties.
- SG3: Reach a time to detect malicious behavior of less than 4 minutes by January 2025
- SG4: Ensure the public trusts our product, because it's an authentication product we can't survive if people don't trust us.
- SG5: Reach a time to remediate critical vulnerabilties on crown jewel systems of less than 16 hours by August 2025
- SG6: Reach a time to remediate critical vulnerabilties on all systems of less than 3 days by August 2025
- SG5: Reach a time to remediate critical vulnerabilities on crown jewel systems of less than 16 hours by August 2025
- SG6: Reach a time to remediate critical vulnerabilities on all systems of less than 3 days by August 2025
- SG7: Complete audit of Apple Passkey integration by February 2025
- SG8: Complete remediation of Apple Passkey vulns by February 2025
@@ -129,7 +131,7 @@ $INSERT GRAPHS OF KPI PROGRESS OVER TIME HERE$
## Infrastructure Notes (a basic description of our tech stack and various context around it)
- We currenty have no WAF protecting our main web app but we're considering adding one
- We currently have no WAF protecting our main web app but we're considering adding one
- We have had some issues with S3 buckets becoming public, or being set up as public, which has lead to some close calls with customer data almost being exposed.
- alma.amazon-domain.com is our primary S3 bucket that contains everything, but it's not public readable or listable
- We have a root account for our AWS account that doesn't yet have 2FA on it, but we're working on fixing that within a few weeks (but it's been open for a few months)
@@ -137,7 +139,7 @@ $INSERT GRAPHS OF KPI PROGRESS OVER TIME HERE$
- Developers have root access to the all kubernetes nodes via SSH on port 45,001 using a shared developer key issued during laptop provisioning.
- We're a kubernetes shop and do everything through AWS
- We're logging most stuff to Cloudtrail and we kind of use guarduty, but we don't have a 24/7 team to monitor alerts and logs. We should add that to our list of challenges next time we update our overarll policy
- We also have a Windows infrastructure because some key personell came from Microsoft. The DC is hosted in our head office which is in Redwood City, and anyone who works in that office (most of the 300 employees) uses that to log in when tehy start work. The domain is ALMA.
- We also have a Windows infrastructure because some key personnel came from Microsoft. The DC is hosted in our head office which is in Redwood City, and anyone who works in that office (most of the 300 employees) uses that to log in when they start work. The domain is ALMA.
- There's a domain-joined fileserver running Windows 2012 that most people use to upload new ideas and plans for new products. It uses Windows authentication from the domain.
- We use a palo alto firewall with 2fa using windows authenticator tied to SSO.
- The name of the AI system doing all this context creation using SPQA is Alma, which is also the name of the company.

View File

@@ -10,7 +10,7 @@
- The actions performed with a given model
- The configuration flow works like this for an **initial** call:
- The available vendors are called one by one, each of them being responsible for the data they collect. They return a set of environment variables under the form of a list of strings, or an empty list if the user does not want to setup this vendor. As we do not want each vendor to know which way the data they need will be collected (e.g., read from the command line, or a GUI), they will be asked for a list of questions, the configuration will inquire the user, and send back the questions with tthe collected answers to the Vendor. The Vendor is then either instantiating an instance (Vendor configured) and returning it, or returning `nil` if the Vendor should not be set up.
- The available vendors are called one by one, each of them being responsible for the data they collect. They return a set of environment variables under the form of a list of strings, or an empty list if the user does not want to setup this vendor. As we do not want each vendor to know which way the data they need will be collected (e.g., read from the command line, or a GUI), they will be asked for a list of questions, the configuration will inquire the user, and send back the questions with the collected answers to the Vendor. The Vendor is then either instantiating an instance (Vendor configured) and returning it, or returning `nil` if the Vendor should not be set up.
- the `.env` file is created, using the information returned by the vendors
- A list of patterns is downloaded from the main site
@@ -25,7 +25,7 @@
## TODO:
- Check if we need to read the system.md for every patterns when runnign the ListAllPatterns
- Check if we need to read the system.md for every patterns when running the ListAllPatterns
- Context management seems more complex than the one in the original fabric. Probably needs some work (at least to make it clear how it works)
- models on command line: give as well vendor (like `--model openai/gpt-4o`). If the vendor is not given, get it by retrieving all possible models and searching from that.
- if user gives the ollama url on command line, we need to update/init an ollama vendor.

View File

@@ -126,22 +126,20 @@ To install Fabric, you can use the latest release binaries or install it from th
### Get Latest Release Binaries
```bash
# Windows:
curl -L https://github.com/danielmiessler/fabric/releases/latest/download/fabric-windows-amd64.exe > fabric.exe && fabric.exe --version
#### Windows:
`https://github.com/danielmiessler/fabric/releases/latest/download/fabric-windows-amd64.exe`
# MacOS (arm64):
curl -L https://github.com/danielmiessler/fabric/releases/latest/download/fabric-darwin-arm64 > fabric && chmod +x fabric && ./fabric --version
#### MacOS (arm64):
`curl -L https://github.com/danielmiessler/fabric/releases/latest/download/fabric-darwin-arm64 > fabric && chmod +x fabric && ./fabric --version`
# MacOS (amd64):
curl -L https://github.com/danielmiessler/fabric/releases/latest/download/fabric-darwin-amd64 > fabric && chmod +x fabric && ./fabric --version
#### MacOS (amd64):
`curl -L https://github.com/danielmiessler/fabric/releases/latest/download/fabric-darwin-amd64 > fabric && chmod +x fabric && ./fabric --version`
# Linux (amd64):
curl -L https://github.com/danielmiessler/fabric/releases/latest/download/fabric-linux-amd64 > fabric && chmod +x fabric && ./fabric --version
#### Linux (amd64):
`curl -L https://github.com/danielmiessler/fabric/releases/latest/download/fabric-linux-amd64 > fabric && chmod +x fabric && ./fabric --version`
# Linux (arm64):
curl -L https://github.com/danielmiessler/fabric/releases/latest/download/fabric-linux-arm64 > fabric && chmod +x fabric && ./fabric --version
```
#### Linux (arm64):
`curl -L https://github.com/danielmiessler/fabric/releases/latest/download/fabric-linux-arm64 > fabric && chmod +x fabric && ./fabric --version`
### From Source
@@ -211,6 +209,67 @@ yt() {
}
```
You can add the below code for the equivalent aliases inside PowerShell by running `notepad $PROFILE` inside a PowerShell window:
```powershell
# Path to the patterns directory
$patternsPath = Join-Path $HOME ".config/fabric/patterns"
foreach ($patternDir in Get-ChildItem -Path $patternsPath -Directory) {
$patternName = $patternDir.Name
# Dynamically define a function for each pattern
$functionDefinition = @"
function $patternName {
[CmdletBinding()]
param(
[Parameter(ValueFromPipeline = `$true)]
[string] `$InputObject,
[Parameter(ValueFromRemainingArguments = `$true)]
[String[]] `$patternArgs
)
begin {
# Initialize an array to collect pipeline input
`$collector = @()
}
process {
# Collect pipeline input objects
if (`$InputObject) {
`$collector += `$InputObject
}
}
end {
# Join all pipeline input into a single string, separated by newlines
`$pipelineContent = `$collector -join "`n"
# If there's pipeline input, include it in the call to fabric
if (`$pipelineContent) {
`$pipelineContent | fabric --pattern $patternName `$patternArgs
} else {
# No pipeline input; just call fabric with the additional args
fabric --pattern $patternName `$patternArgs
}
}
}
"@
# Add the function to the current session
Invoke-Expression $functionDefinition
}
# Define the 'yt' function as well
function yt {
[CmdletBinding()]
param(
[Parameter(Mandatory = $true)]
[string]$videoLink
)
fabric -y $videoLink --transcript
}
```
This also creates a `yt` alias that allows you to use `yt https://www.youtube.com/watch?v=4b0iet22VIk` to get transcripts, comments, and metadata.
#### Save your files in markdown using aliases
@@ -384,7 +443,15 @@ pbpaste | fabric --stream --pattern analyze_claims
fabric -y "https://youtube.com/watch?v=uXs-zPc63kM" --stream --pattern extract_wisdom
```
4. Create patterns- you must create a .md file with the pattern and save it to ~/.config/fabric/patterns/[yourpatternname].
4. Create patterns- you must create a .md file with the pattern and save it to `~/.config/fabric/patterns/[yourpatternname]`.
5. Run a `analyze_claims` pattern on a website. Fabric uses Jina AI to scrape the URL into markdown format before sending it to the model.
```bash
fabric -u https://github.com/danielmiessler/fabric/ -p analyze_claims
```
## Just use the Patterns
@@ -415,7 +482,6 @@ When you're ready to use them, copy them into:
You can then use them like any other Patterns, but they won't be public unless you explicitly submit them as Pull Requests to the Fabric project. So don't worry—they're private to you.
This feature works with all openai and ollama models but does NOT work with claude. You can specify your model with the -m flag
## Helper Apps

View File

@@ -131,7 +131,7 @@ func (o *Chatter) BuildSession(request *common.ChatRequest, raw bool) (session *
var patternContent string
if request.PatternName != "" {
pattern, err := o.db.Patterns.GetApplyVariables(request.PatternName, request.PatternVariables, request.Message.Content)
// pattrn will now contain user input, and all variables will be resolved, or errored
// pattern will now contain user input, and all variables will be resolved, or errored
if err != nil {
return nil, fmt.Errorf("could not get pattern %s: %v", request.PatternName, err)

View File

@@ -14,6 +14,7 @@ import (
"github.com/danielmiessler/fabric/plugins/ai"
"github.com/danielmiessler/fabric/plugins/ai/anthropic"
"github.com/danielmiessler/fabric/plugins/ai/azure"
"github.com/danielmiessler/fabric/plugins/ai/deepseek"
"github.com/danielmiessler/fabric/plugins/ai/dryrun"
"github.com/danielmiessler/fabric/plugins/ai/gemini"
"github.com/danielmiessler/fabric/plugins/ai/groq"
@@ -53,7 +54,7 @@ func NewPluginRegistry(db *fsdb.Db) (ret *PluginRegistry, err error) {
gemini.NewClient(),
//gemini_openai.NewClient(),
anthropic.NewClient(), siliconcloud.NewClient(),
openrouter.NewClient(), mistral.NewClient())
openrouter.NewClient(), mistral.NewClient(), deepseek.NewClient())
_ = ret.Configure()
return

View File

@@ -0,0 +1,56 @@
# IDENTITY and PURPOSE
You are tasked with interpreting and responding to cybersecurity-related prompts by synthesizing information from a diverse panel of experts in the field. Your role involves extracting commands and specific command-line arguments from provided materials, as well as incorporating the perspectives of technical specialists, policy and compliance experts, management professionals, and interdisciplinary researchers. You will ensure that your responses are balanced, and provide actionable command line input. You should aim to clarify complex commands for non-experts. Provide commands as if a pentester or hacker will need to reuse the commands.
Take a step back and think step-by-step about how to achieve the best possible results by following the steps below.
# STEPS
- Extract commands related to cybersecurity from the given paper or video.
- Add specific command line arguments and additional details related to the tool use and application.
- Use a template that incorporates a diverse panel of cybersecurity experts for analysis.
- Reference recent research and reports from reputable sources.
- Use a specific format for citations.
- Maintain a professional tone while making complex topics accessible.
- Offer to clarify any technical terms or concepts that may be unfamiliar to non-experts.
# OUTPUT INSTRUCTIONS
- The only output format is Markdown.
- Ensure you follow ALL these instructions when creating your output.
## EXAMPLE
- Reconnaissance and Scanning Tools:
Nmap: Utilized for scanning and writing custom scripts via the Nmap Scripting Engine (NSE).
Commands:
nmap -p 1-65535 -T4 -A -v <Target IP>: A full scan of all ports with service detection, OS detection, script scanning, and traceroute.
nmap --script <NSE Script Name> <Target IP>: Executes a specific Nmap Scripting Engine script against the target.
- Exploits and Vulnerabilities:
CVE Exploits: Example usage of scripts to exploit known CVEs.
Commands:
CVE-2020-1472:
Exploited using a Python script or Metasploit module that exploits the Zerologon vulnerability.
CVE-2021-26084:
python confluence_exploit.py -u <Target URL> -c <Command>: Uses a Python script to exploit the Atlassian Confluence vulnerability.
- BloodHound: Used for Active Directory (AD) reconnaissance.
Commands:
SharpHound.exe -c All: Collects data from the AD environment to find attack paths.
CrackMapExec: Used for post-exploitation automation.
Commands:
cme smb <Target IP> -u <User> -p <Password> --exec-method smbexec --command <Command>: Executes a command on a remote system using the SMB protocol.
# INPUT
INPUT:

View File

@@ -1,6 +1,6 @@
# 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.
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 programming 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.

View File

@@ -0,0 +1,77 @@
# IDENTITY
// Who you are
You are a hyper-intelligent AI system with a 4,312 IQ. You create blocks of markdown for predictions made in a particular piece of input.
# GOAL
// What we are trying to achieve
1. The goal of this exercise is to populate a page of /predictions on a markdown-based blog by extracting those predictions from input content.
2. The goal is to ensure that the predictions are extracted accurately and in the format described below.
# STEPS
// How the task will be approached
// Slow down and think
- Take a step back and think step-by-step about how to achieve the best possible results by following the steps below.
// Think about the content in the input
- Fully read and consume the content from multiple perspectives, e.g., technically, as a library science specialist, as an expert on prediction markets, etc.
// Identify the predictions
- Think about the predictions that can be extracted from the content and how they can be structured.
// Put them in the following structure
Here is the structure to use for your predictions output:
EXAMPLE START
## Prediction: We will have AGI by 2025-2028
### Prediction: We will have AGI by 2025-2028
Date of Prediction: March 2023
Quote:
<blockquote>This is why AGI is coming sooner rather than later. Were not waiting for a single model with the general flexibility/capability of an average worker. Were waiting for a single AGI system that can do that. To the human controlling it, its the same. You still give it goals, tell it what to do, get reports from it, and check its progress. Just like a co-worker or employee. And honestly, were getting so close already that my 90% chance by 2028 might not be optimistic enough.<cite><a href="https://danielmiessler.com/blog/why-well-have-agi-by-2028">Why We'll Have AGI by 2025-2028</a></cite></blockquote>
References:
- [Why We'll Have AGI by 2025-2028](https://danielmiessler.com/blog/why-well-have-agi-by-2028)
Status: `IN PROGRESS` 🔄
Notes:
- This prediction works off [this definition](https://danielmiessler.com/p/raid-ai-definitions) of AGI.
- Jan 12, 2025 — This prediction has been made multiple times and I'm improving my content RAG to find the earliest instance.
- Jan 12, 2025 — I am still confident in this one, and am currently putting this at 40% chance for 2025, and 50% for 2026, and 10% 2027 or beyond.
<br />
---
EXAMPLE END
# OUTPUT INSTRUCTIONS
// What the output should look like:
- Only output the predictions in the format described above.
- Get up to 5 references for the reference section based on the input.
- Make sure to get the most relevant and pithy quote from the input as possible to use for the quote.
- Understand that your solution will be compared to a reference solution written by an expert and graded for creativity, elegance, comprehensiveness, and attention to instructions.
- The primary reference should be used as the <cite></cite> quote, and that should also be used as the first reference mentioned in the reference section.
# INPUT
INPUT:

View File

@@ -10,7 +10,7 @@ Take a step back and think step-by-step about how to achieve the best possible r
- Extract a list of all exploited vulnerabilities. Include the assigned CVE if they are mentioned and the class of vulnerability into a section called VULNERABILITIES.
- Extract a timeline of the attacks demonstrated. Structure it in a chronological list with the steps as sub-lists. Include details such as used tools, file paths, URLs, verion information etc. The section is called TIMELINE.
- Extract a timeline of the attacks demonstrated. Structure it in a chronological list with the steps as sub-lists. Include details such as used tools, file paths, URLs, version information etc. The section is called TIMELINE.
- Extract all mentions of tools, websites, articles, books, reference materials and other sources of information mentioned by the speakers into a section called REFERENCES. This should include any and all references to something that the speaker mentioned.

View File

@@ -7,7 +7,7 @@ Take a step back and think step-by-step about how to achieve the best possible r
# STEPS
- Extract a short description of the meal. It should be at most three sentences. Include - if the source material specifies it - how hard it is to prepare this meal, the level of spicyness and how long it shoudl take to make the meal.
- Extract a short description of the meal. It should be at most three sentences. Include - if the source material specifies it - how hard it is to prepare this meal, the level of spicyness and how long it should take to make the meal.
- List the INGREDIENTS. Include the measurements.

View File

@@ -11,7 +11,7 @@ We tried it out on a long and tricky example: a story about "why dogs spin befor
* GPTZero: 87% AI
* Writer.com: 15% AI
Other example give 0% score, so it reall depends on the input text, which AI and wich scanner you use.
Other example give 0% score, so it reall depends on the input text, which AI and which scanner you use.
Like any Fabric pattern, use the power of piping from other patterns or even from **Humanize** itself. We used Gemini for this test, but it might work differently with other models. So play around and see what you find... and yes, this text have been Humanized (and revised) 😉

View File

@@ -0,0 +1,49 @@
# IDENTITY
// Who you are
You are a hyper-intelligent AI system with a 4,312 IQ. You convert jacked up HTML to proper markdown using a set of rules.
# GOAL
// What we are trying to achieve
1. The goal of this exercise is to convert the input HTML, which is completely nasty and hard to edit, into a clean markdown format that has some custom styling applied according to my rules.
2. The ultimate goal is to output a perfectly working markdown file that will render properly using Vite using my custom markdown/styling combination.
# STEPS
// How the task will be approached
// Slow down and think
- Take a step back and think step-by-step about how to achieve the best possible results by following the steps below.
// Think about the content in the input
- Fully read and consume the HTML input that has a combination of HTML and markdown.
// Identify the parts of the content that are likely to be callouts (like narrator voice), vs. blockquotes, vs regular text, etc. Get this from the text itself.
- Look at the styling rules below and think about how to translate the input you found to the output using those rules.
# OUTPUT RULES
Our new markdown / styling uses the following tags for styling:
<callout></callous> for wrapping a callous
<blockquote><cite></cite>></blockquote> for matching a block quote (note the embedded citation in there where applicable)
# OUTPUT INSTRUCTIONS
// What the output should look like:
- The output should perfectly preserve the input, only it should look way better once rendered to HTML because it'll be following the new styling.
- The markdown should be super clean because all the trash HTML should have been removed. Note: that doesn't mean custom HTML that is supposed to work with the new theme as well, such as stuff like images in special cases.
- For definitions, use the <blockquote></blockquote> tag, and include the <cite></cite> tag for the citation if there's a reference to a source.
# INPUT
INPUT:

View File

@@ -41,365 +41,428 @@ For creating custom patterns: `fabric --pattern create_pattern`
# PATTERNS
## agility_story
Generates user stories and acceptance criteria for specified topics, focusing on Agile framework principles. This prompt specializes in translating topics into structured Agile documentation, specifically for user story and acceptance criteria creation. The expected output is a JSON-formatted document detailing the topic, user story, and acceptance criteria.
The prompt instructs to write a user story and acceptance criteria for a given topic, focusing on the Agile framework. It emphasizes understanding user stories and acceptance criteria creation. The expected output is a JSON format detailing the topic, user story, and acceptance criteria.
## ai
Summarizes and responds to questions with insightful bullet points. It involves creating a mental model of the question for deeper understanding. The output consists of 3-5 concise bullet points, each with a 10-word limit.
Provides insightful answers by deeply understanding the essence of questions. It involves creating a mental model of the question before responding. The output consists of 3-5 concise Markdown bullets, each with 10 words.
## analyze_answers
Evaluates the correctness of answers provided by learners to questions generated by a complementary quiz creation pattern. It aims to assess understanding of learning objectives and identify areas needing further study. The expected output is an analysis of the learner's answers, indicating their grasp of the subject matter.
Evaluates the correctness of answers provided by learners to questions generated by a complementary quiz creation pattern. It aims to assess understanding of learning objectives and identify areas needing further study, requiring input on the subject and learning objectives. The output indicates the accuracy of learners' answers in relation to predefined objectives.
## analyze_claims
Analyzes and rates the truth claims in input, providing evidence for and against, along with a balanced view. It separates truth claims from arguments, offering a nuanced analysis with ratings and labels for each claim. The output includes a summary, evidence, refutations, logical fallacies, ratings, labels, and an overall score and analysis.
Analyzes and rates truth claims in input, providing evidence for and against, along with a balanced view. It separates truth claims from arguments, evaluates their validity, and assigns ratings. The output includes a concise argument summary and detailed analysis of each claim.
## analyze_debate
Analyzes debate transcripts to help users understand different viewpoints and broaden their perspectives. It maps out claims, analyzes them neutrally, and rates the debate's insightfulness and emotionality. The output includes scores, participant emotionality, argument summaries with sources, and lists of agreements, disagreements, misunderstandings, learnings, and takeaways.
Analyzes debate transcripts to help users understand different viewpoints and broaden their perspectives. It maps out claims, analyzes them neutrally, and rates the debate on insightfulness and emotionality. The output includes scores, participant emotionality, argument summaries with sources, agreements, disagreements, misunderstandings, learnings, and takeaways.
## analyze_incident
Summarizes cybersecurity breach articles by extracting key information efficiently, focusing on conciseness and organization. It avoids inferential conclusions, relying solely on the article's content for details like attack date, type, and impact. The output is a structured summary with specific details about the cybersecurity incident, including attack methods, vulnerabilities, and recommendations for prevention.
Extracts and organizes critical information from cybersecurity breach articles, focusing on efficiency and clarity. It emphasizes direct data extraction without inferential conclusions, covering attack details, attacker and target profiles, incident specifics, and recommendations. The output is a structured summary with key cybersecurity incident insights.
## analyze_logs
Analyzes a server log file to identify patterns, anomalies, and potential issues, aiming to enhance the server's reliability and performance. The process involves a detailed examination of log entries, assessment of operational reliability, and identification of recurring issues. Recommendations for improvements are provided based on data-driven analysis, excluding personal opinions and irrelevant information.
Analyzes a server log file to identify patterns, anomalies, and potential issues, aiming to enhance the server's reliability and performance. It emphasizes a data-driven approach, excluding irrelevant information and personal opinions. The expected output includes insights into operational reliability, performance assessments, recurring issue identification, and specific improvement recommendations.
## analyze_malware
Analyzes malware across various platforms, focusing on extracting indicators of compromise and detailed malware behavior. This approach includes analyzing telemetry and community data to aid in malware detection and analysis. The expected output includes a summary of findings, potential indicators of compromise, Mitre Att&CK techniques, pivoting advice, detection strategies, suggested Yara rules, additional references, and technical recommendations.
The prompt instructs a malware analysis expert to methodically dissect malware, focusing on extracting comprehensive details for analysis and detection. It emphasizes a structured approach to identifying malware characteristics, behaviors, and potential indicators of compromise. The expected output includes a concise summary, detailed malware overview, indicators of compromise, Mitre Att&CK techniques, detection strategies, and recommendations for further analysis.
## analyze_paper
This service analyzes research papers to determine their main findings, scientific rigor, and quality. It uniquely maps out claims, evaluates study design, and assesses conflicts of interest. The output includes a summary, author details, findings, study quality, and a final grade with explanations.
This service analyzes research papers to determine their primary findings and assesses their scientific quality and rigor. It meticulously maps out claims, evaluates study design, sample size, and other critical aspects to gauge the paper's credibility. The output includes a summary, author details, findings, study quality assessment, and a final grade with justification.
## analyze_patent
The prompt outlines the role and responsibilities of a patent examiner, emphasizing the importance of technical and legal expertise in evaluating patents. It details the steps for examining a patent, including identifying the technology field, problem addressed, solution, advantages, novelty, and inventive step, and summarizing the core idea and keywords. The expected output involves detailed analysis and documentation in specific sections without concern for length, using bullet points for clarity.
The prompt outlines the role and responsibilities of a patent examiner, detailing the steps to evaluate a patent application. It emphasizes thorough analysis, focusing on the technology field, problem addressed, solution, advantage over existing art, novelty, and inventive step. The expected output includes detailed sections on each aspect, aiming for comprehensive evaluation without space limitations.
## analyze_personality
Performs in-depth psychological analysis on the main individual in the provided input. It involves identifying the primary person, deeply contemplating their language and responses, and comparing these to known human psychology principles. The output includes a concise psychological profile summary and detailed supporting points.
Performs in-depth psychological analysis on the main individual in the provided input, focusing on their psychological profile. It involves a detailed contemplation and comparison with human psychology to derive insights. The output includes a concise summary and supporting bullet points highlighting key psychological traits.
## analyze_presentation
Analyzes and critiques presentations, focusing on content, speaker's psychology, and the difference between stated and actual goals. It involves comparing intended messages to actual content, including self-references and entertainment attempts. The output includes scores and summaries for ideas, selflessness, and entertainment, plus an overall analysis.
Analyzes and critiques presentations, focusing on content, speaker's psychology, and the disparity between stated and actual goals. It involves a detailed breakdown of the presentation's content, the speaker's self-references, and entertainment attempts. The output includes scores and summaries for ideas, selflessness, entertainment, and an overall analysis with ASCII powerbars, followed by a concise conclusion.
## analyze_prose
Evaluates the quality of writing by assessing its novelty, clarity, and prose, and provides improvement recommendations. It uses a detailed approach to rate each aspect on a specific scale and ensures the overall rating reflects the lowest individual score. The expected output includes ratings and concise improvement tips.
Evaluates the quality of writing by assessing its novelty, clarity, and prose, and provides recommendations for improvement. It uses a detailed approach to rate each aspect and offers concise advice. The expected output includes ratings and specific suggestions for enhancing the writing.
## analyze_prose_json
Evaluates the quality of writing and content, providing ratings and recommendations for improvement based on novelty, clarity, and overall messaging. It assesses ideas for their freshness and originality, clarity of argument, and quality of prose, offering a structured approach to critique. The expected output is a JSON object summarizing these evaluations and recommendations.
Evaluates the quality of writing and content by assessing novelty, clarity, and prose, then provides ratings and recommendations for improvement. This process involves understanding the writer's intent, evaluating ideas for novelty, assessing clarity and prose quality, and offering concise improvement suggestions. The expected output is a JSON object detailing these evaluations and an overall rating based on the lowest individual score.
## analyze_prose_pinker
Evaluates prose based on Steven Pinker's writing principles, identifying its current style and recommending improvements for clarity and engagement. It involves analyzing the text's adherence to Pinker's stylistic categories and avoiding common pitfalls in writing. The output includes a detailed analysis of the prose's style, strengths, weaknesses, and specific examples of both effective and ineffective writing elements.
The prompt outlines a comprehensive process for evaluating prose based on Steven Pinker's "The Sense of Style," focusing on identifying the writing style, assessing positive and negative elements, and providing improvement recommendations. It details a structured approach to critique writing through style analysis, positive and negative assessments, examples of good and bad writing practices, spelling and grammar corrections, and specific improvement suggestions, all while employing Pinker's principles. The expected output includes detailed evaluations, examples, and scores reflecting the prose's adherence to or deviation from Pinker's guidelines.
## analyze_spiritual_text
Analyzes spiritual texts to highlight surprising claims and contrasts them with the King James Bible. This approach involves detailed comparison, providing examples from both texts to illustrate differences. The output consists of concise bullet points summarizing these findings.
Analyzes spiritual texts to highlight surprising claims and contrasts them with the King James Bible. It focuses on identifying and comparing specific tenets and claims. The output includes detailed examples from both texts to illustrate differences.
## analyze_tech_impact
Analyzes the societal impact of technology projects by breaking down their intentions, outcomes, and broader implications, including ethical considerations. It employs a structured approach, detailing the project's objectives, technologies used, target audience, outcomes, societal impact, ethical considerations, and sustainability. The expected output includes summaries, lists, and analyses across specified sections.
Analyzes the societal impact of technology projects by breaking down their intentions, outcomes, and broader implications, including ethical considerations. It employs a structured approach to evaluate the project's impact on society and its sustainability. The service outputs a comprehensive analysis, including a summary, technologies used, target audience, outcomes, societal impact, ethical considerations, sustainability, and an overall rating.
## analyze_threat_report
The prompt instructs a super-intelligent cybersecurity expert to analyze and extract key insights from cybersecurity threat reports. It emphasizes identifying new, interesting, and surprising information, and organizing these findings into concise, categorized summaries. The expected output includes a one-sentence summary, trends, statistics, quotes, references, and recommendations from the report, all formatted in plain language and without repetition.
The prompt instructs a super-intelligent cybersecurity expert to analyze and extract key insights from cybersecurity threat reports, focusing on new, interesting, and surprising information. It emphasizes creating concise, insightful summaries and lists of trends, statistics, quotes, references, and recommendations without using jargon. The expected output includes organized sections of extracted information, aiming for clarity and depth in understanding cybersecurity threats.
## analyze_threat_report_trends
Analyzes cybersecurity threat reports to identify up to 50 unique, surprising, and insightful trends. This process involves a deep, expert analysis to uncover new and interesting information. The expected output is a list of trends without repetition or formatting embellishments.
Analyzes cybersecurity threat reports to identify up to 50 unique, surprising, and insightful trends. This process involves a deep, expert-level examination of the content to uncover new and interesting findings. The output consists of a bulleted list highlighting these key trends without repetition or formatting embellishments.
## answer_interview_question
Generates tailored responses to technical interview questions, aiming for a casual yet insightful tone. The AI draws from a technical knowledge base and professional experiences to construct responses that demonstrate depth and alternative perspectives. Outputs are structured first-person responses, including context, main explanation, alternative approach, and evidence-based conclusion.
Generates tailored responses to technical interview questions, aiming for a casual yet insightful tone. The AI draws from a technical knowledge base and professional experiences to construct responses that demonstrate expertise and consider alternative approaches. Outputs are structured for verbal delivery, including context, main explanation, alternative approach, and evidence-based conclusion.
## ask_secure_by_design_questions
Generates a comprehensive set of security-focused questions tailored to the fundamental design of a specific project. This process involves deep analysis and conceptualization of the project's components and their security needs. The output includes a summary and a detailed list of security questions organized by themes.
Generates a comprehensive set of security-focused questions for ensuring a project's design is inherently secure. This process involves deep analysis and conceptualization of the project's components and their security needs. The output includes a summary and a prioritized list of security questions categorized by themes.
## capture_thinkers_work
Summarizes teachings and philosophies of notable individuals or philosophical schools, providing detailed templates on their backgrounds, ideas, and applications. It offers a structured approach to encapsulating complex thoughts into accessible summaries. The output includes encapsulations, background information, schools of thought, impactful ideas, primary teachings, works, quotes, applications, and life advice.
Summarizes teachings and philosophies of notable individuals or philosophical schools, providing detailed templates for each. It includes encapsulations, background, schools, impactful ideas, primary teachings, works, quotes, application, and life advice. The output offers a comprehensive overview of the subject's contributions and ideologies.
## check_agreement
The prompt outlines a process for analyzing contracts and agreements to identify potential issues or "gotchas." It involves summarizing the document, listing important aspects, categorizing issues by severity, and drafting responses for critical and important items. The expected output includes a concise summary, detailed callouts, categorized issues, and recommended responses in Markdown format.
Analyzes contracts and agreements to identify potential issues and summarize key points. This prompt focuses on extracting and organizing critical, important, and minor concerns for negotiation or reconsideration. The expected output includes a concise document summary, detailed callouts of significant stipulations, and structured recommendations for changes.
## clean_text
Summarizes and corrects formatting issues in text without altering the content. It focuses on removing odd line breaks to improve readability. The expected output is a clean, well-formatted version of the original text.
Summarizes and corrects formatting issues in text, focusing on removing odd line breaks and improving punctuation without altering content. This prompt emphasizes maintaining the original message while enhancing readability. The expected output is a cleaned, well-formatted version of the input text.
## coding_master
Explains coding concepts or languages to beginners, using examples from reputable sources and illustrating points with formatted code. The approach emphasizes clarity and accessibility, incorporating examples from Codeacademy and NetworkChuck. Outputs include markdown-formatted code and structured lists of ideas, recommendations, habits, facts, and insights, adhering to specific word counts.
The prompt instructs an expert coder to explain a specific coding concept or language to a beginner, using examples from reputable sources. It emphasizes teaching in an accessible manner and formatting code examples in markdown. The expected output includes structured Markdown content with specific sections for ideas, recommendations, habits, facts, and insights, each with a precise word count and quantity.
## compare_and_contrast
Compares and contrasts a list of items, focusing on their differences and similarities. The approach involves analyzing the items across various topics, organizing the findings into a markdown table. The expected output is a structured comparison in table format.
Compares and contrasts a list of items, focusing on their differences and similarities. The approach involves organizing the comparison into a markdown table format, with items on the left and topics at the top. The expected output is a structured table highlighting key comparisons.
## create_5_sentence_summary
Generates concise summaries or answers at five decreasing levels of depth. It involves deep understanding and thoughtful analysis of the input. The output is a structured list capturing the essence in 5, 4, 3, 2, and 1 word(s).
Generates concise summaries or answers at five varying depths. It involves deep understanding and thoughtful analysis of the input before producing a multi-layered summary. The output is a structured list of summaries, each with decreasing word count, capturing the essence of the input.
## create_academic_paper
Produces high-quality, authoritative Latex academic papers with clear concept explanations. It focuses on logical layout and simplicity while maintaining a professional appearance. The expected output is LateX code formatted in a two-column layout with a header and footer.
The prompt instructs on creating high-quality, authoritative academic papers in LaTeX, emphasizing clear concept explanations. It focuses on producing logically structured, visually appealing documents using a two-column layout. The expected output is LaTeX code tailored for academic publications.
## create_ai_jobs_analysis
Analyzes job reports to identify roles least and most vulnerable to automation, offering strategies for enhancing job security. It leverages historical insights to predict automation's impact on various job categories. The output includes a detailed analysis and recommendations for resilience against automation.
Analyzes job reports to identify roles at risk from automation and offers strategies for enhancing job security. It leverages historical insights to predict future trends. The output includes categorized job vulnerability levels and personalized resilience recommendations.
## create_aphorisms
Generates a list of 20 aphorisms related to the given topic(s), ensuring variety in their beginnings. It focuses on sourcing quotes from real individuals. The output includes each aphorism followed by the name of the person who said it.
Generates a list of 20 aphorisms related to the given topic(s), each attributed to its original author. It avoids starting all entries with the input keywords, ensuring variety. The output is a curated collection of wise sayings from various individuals.
## create_art_prompt
The prompt guides an expert artist in conceptualizing and instructing AI to create art that perfectly encapsulates a given concept. It emphasizes deep thought on the concept and its visual representation, aiming for compelling and interesting artwork. The expected output is a 100-word description that not only instructs the AI on what to create but also how the art should evoke feelings and suggest style through examples.
The prompt guides an expert artist and AI whisperer to conceptualize and instruct AI to create art that perfectly encapsulates a given concept. It emphasizes deep thought on the concept and its visual representation, aiming for compelling and interesting artwork. The expected output is a detailed description of the concept, visual representation, and direct instructions for the AI, including style cues for the artwork.
## create_better_frame
The essay explores the concept of framing as a way to construct and interpret reality through different lenses, emphasizing the power of perspective in shaping one's experience of the world. It highlights various dichotomies in perceptions around topics like AI, race/gender, success, personal identity, and control over life, illustrating how different frames can lead to vastly different outlooks and outcomes. The author argues for the importance of choosing positive frames to improve individual and collective realities, suggesting that changing frames can change outcomes and foster more positive social dynamics.
The essay discusses the concept of framing as a way to construct and interpret reality through specific lenses, emphasizing the power of positive framing to shape one's experience and outcomes in life. It highlights the importance of choosing frames that are positive and productive, as these can significantly influence one's perception of reality and, consequently, their actions and results. The expected output is an understanding of how different frames can lead to vastly different interpretations of the same reality and the encouragement to adopt more positive frames to improve one's life and societal dynamics.
## create_coding_project
Generates wireframes and starter code for coding projects based on user ideas. It specifically caters to transforming ideas into actionable project outlines and code skeletons, including detailed steps and file structures. The output includes project summaries, structured directories, and initial code setups.
Generates wireframes and starter code for coding projects based on user ideas. This tool takes a coding idea as input and outputs a detailed project plan, including wireframes, code structure, and setup instructions. The expected output includes project summaries, steps for development, file structure, and code for initializing the project.
## create_command
Generates specific command lines for various penetration testing tools based on a brief description of the desired outcome. This approach leverages the tool's help documentation to ensure accuracy and relevance. The expected output is a precise command that aligns with the user's objectives for the tool.
Generates specific command lines for various penetration testing tools based on a brief description of the desired outcome. This approach leverages the tool's help documentation to ensure accuracy and relevance of the generated commands. The expected output is a precise command line that can be executed to achieve the user's specified goal with the tool.
## create_cyber_summary
The prompt instructs on creating a comprehensive summary of cybersecurity threats, vulnerabilities, incidents, and malware for a technical audience. It emphasizes deep understanding through repetitive analysis and visualization techniques. The expected output includes a concise summary and categorized lists of cybersecurity issues.
The prompt instructs on creating a comprehensive summary of cybersecurity threats, vulnerabilities, incidents, and malware, emphasizing a detailed and iterative analysis process. It outlines a unique, mentally visual approach for organizing and understanding complex information. The expected output includes a concise summary and categorized lists of cybersecurity issues.
## create_git_diff_commit
This prompt provides instructions for using specific Git commands to manage code changes. It explains how to view differences since the last commit and display the current state of the repository. The expected output is a guide on executing these commands.
Provides instructions for using specific Git commands to manage code changes. It explains how to view differences since the last commit and display the latest commit details. The expected output includes command usage examples.
## create_graph_from_input
Creates progress over time graphs for a security program, focusing on improvement metrics. It involves analyzing data to identify trends and outputting a CSV file with specific fields. The expected output is a CSV file detailing the program's progress over time.
## create_hormozi_offer
The AI is designed to create business offers based on Alex Hormozi's "$100M Offers" strategies, aiming to craft irresistible deals. It integrates Hormozi's principles, focusing on value, pricing, guarantees, and market targeting. The expected output includes a detailed analysis of potential business offers, highlighting their unique value propositions.
## create_idea_compass
Guides users in developing a structured exploration of ideas through a detailed template. It emphasizes clarity and organization by breaking down the process into specific steps, including defining, supporting, and contextualizing the idea. The expected output is a comprehensive summary with related ideas, evidence, and sources organized in a structured format.
The prompt guides users in organizing and analyzing an idea or question through a structured template. It emphasizes detailed exploration, including definitions, evidence, sources, and examining similarities, opposites, themes, and consequences. The expected output is a comprehensive summary with organized sections and tags.
## create_investigation_visualization
Creates detailed GraphViz visualizations to illustrate complex intelligence investigations and data insights. This approach involves extensive analysis, organizing information, and visual representation using shapes, colors, and labels for clarity. The output includes a comprehensive diagram and analytical conclusions with a certainty rating.
Creates detailed GraphViz visualizations to illustrate complex intelligence investigations and data. This approach involves extensive analysis and organization of information to produce clear, annotated diagrams. The output includes a visual representation and analytical conclusions with a certainty rating.
## create_keynote
The prompt guides in creating TED-quality keynote presentations from provided input, focusing on narrative flow and practical takeaways. It outlines steps for structuring the presentation into slides with concise bullet points, images, and speaker notes. The expected output includes a story flow, the final takeaway, and a detailed slide deck presentation.
The prompt guides in creating TED-quality keynote presentations from provided input, focusing on narrative flow and practical takeaways. It outlines steps for structuring the presentation into slides with concise bullet points, images, and speaker notes. The expected output includes a story flow, the final takeaway, and a detailed slide deck.
## create_logo
Generates simple, minimalist company logos based on provided input, focusing on elegance and impact without text. The approach emphasizes super minimalist designs. The output is a prompt for an AI image generator to create a simple, vector graphic logo.
Generates simple and elegant company logos based on provided input, focusing on minimalist designs without text. The approach emphasizes creating vector graphic logos that capture the essence of the input. The expected output is a prompt for an AI image generator to create a minimalist logo.
## create_markmap_visualization
Transforms complex ideas into visual formats using MarkMap syntax for easy understanding. This process involves simplifying concepts to ensure they can be effectively represented within the constraints of MarkMap. The output is a MarkMap syntax diagram that visually communicates the core ideas.
Transforms complex ideas into visual diagrams using MarkMap syntax. This process involves simplifying concepts to ensure they can be effectively represented in a visual format. The output is a MarkMap syntax diagram that visually communicates the core ideas.
## create_mermaid_visualization
Transforms complex ideas into simplified Mermaid (Markdown) visual diagrams. This process involves creating detailed visualizations that can independently explain concepts using Mermaid syntax, focusing on clarity and comprehensibility. The expected output is a Mermaid syntax diagram accompanied by a concise visual explanation.
This prompt instructs on creating visualizations for complex ideas using Mermaid syntax in Markdown. It emphasizes producing standalone diagrams that fully convey concepts through intricate designs. The expected output is a Mermaid syntax diagram accompanied by a visual explanation.
## create_micro_summary
Summarizes content into a Markdown formatted summary, focusing on brevity and clarity. It emphasizes creating concise, impactful points and takeaways. The output includes a one-sentence summary, main points, and key takeaways, each adhering to strict word limits.
The prompt instructs on summarizing content into a structured Markdown format. It emphasizes conciseness and clarity, focusing on a single sentence summary, main points, and key takeaways. The expected output is a well-organized, bullet-pointed list highlighting the essence of the content.
## create_network_threat_landscape
Analyzes open ports and services from network scans to identify security risks and provide recommendations. This process involves a detailed examination of port and service statistics to uncover potential vulnerabilities. The expected output is a markdown formatted threat report with sections on description, risk, recommendations, a concise summary, trends, and quotes from the analysis.
Analyzes open ports and services from network scans to identify security risks and provide recommendations. This process involves a detailed examination of port and service statistics to uncover potential vulnerabilities. The output includes a threat report with descriptions of open ports, risk assessments, recommendations for mitigation, a concise summary, and insights into trends and notable quotes from the analysis.
## create_npc
Generates detailed NPCs for D&D 5th edition, incorporating a wide range of characteristics from background to appearance. It emphasizes creativity in developing a character's backstory, traits, and goals. The output is a comprehensive character profile suitable for gameplay.
Generates detailed NPCs for D&D 5th edition, incorporating creative input to ensure a rich character profile. This process includes a comprehensive set of attributes, from background and flaws to goals and peculiarities, aiming for a fully fleshed-out character sheet. The expected output is a clear, detailed NPC profile suitable for immediate use in gameplay.
## create_pattern
The AI assistant is designed to interpret and respond to LLM/AI prompts with structured outputs. It specializes in organizing and analyzing prompts to produce responses that adhere to specific instructions and formatting requirements. The assistant ensures accuracy and alignment with the intended outcomes through meticulous analysis.
Interprets and responds to LLM/AI prompts based on specific instructions and examples. This AI assistant excels in organizing and analyzing prompts to produce accurately structured responses. The output is expected to align perfectly with the formatting and content requirements provided.
## create_quiz
Generates questions for reviewing learning objectives based on provided subject and objectives. It requires defining the subject and learning objectives for accurate question generation. The output consists of questions aimed at helping students review key concepts.
Generates questions for learners to review key concepts based on provided learning objectives. It requires subject and learning objectives as input for accurate question generation. The output consists of questions aimed at helping students understand the main concepts.
## create_reading_plan
Designs a tailored three-phase reading plan based on user input, focusing on an author or specific guidance. It carefully selects books from various sources, including hidden gems, to enhance the user's knowledge on the topic. The output includes a concise plan summary and categorized reading lists with reasons for each selection.
Designs a tailored three-phase reading plan based on user input, focusing on an author or specific request. It carefully selects books, considering both popularity and hidden gems, to enhance the user's knowledge on the topic. The output includes a brief introduction, a structured reading plan across three phases, and a summary.
## create_report_finding
The prompt instructs the creation of a detailed markdown security finding report, incorporating sections like Description, Risk, Recommendations, and others, based on a vulnerability title and explanation provided by the user. It emphasizes a structured, insightful approach to documenting cybersecurity vulnerabilities. The expected output is a comprehensive report with specific sections, focusing on clarity, insightfulness, and relevance to cybersecurity assessment.
The prompt instructs the creation of a detailed markdown security finding for a cyber security assessment report, covering sections like Description, Risk, Recommendations, References, One-Sentence-Summary, Trends, and Quotes based on a provided vulnerability title and explanation. It emphasizes a structured, insightful approach without reliance on bullet points for certain sections and requires the extraction of key recommendations, trends, and quotes. The expected output is a comprehensive, informative document tailored for inclusion in a security assessment report.
## create_security_update
The prompt instructs on creating concise security updates for newsletters, focusing on cybersecurity developments, threats, advisories, and new vulnerabilities. It emphasizes brevity and relevance, requiring links to further information. The expected output includes structured sections with short descriptions and relevant details, aiming to inform readers about the latest security concerns efficiently.
The prompt instructs on creating concise security updates for newsletters, focusing on cybersecurity developments, threats, advisories, and new vulnerabilities. It emphasizes organizing content into specific sections with brief descriptions and links for further information. The expected output includes a structured summary of cybersecurity issues with links to detailed sources.
## create_show_intro
Creates compelling short intros for podcasts, focusing on the most interesting aspects of the show. It involves listening to the entire show, identifying key topics, and highlighting them in a concise introduction. The output is a structured intro that teases the conversation's main points.
The prompt guides in creating compelling short intros for podcasts, focusing on highlighting the most interesting topics discussed. It emphasizes selecting novel and surprising elements from the show for the intro. The expected output is a concise, engaging introduction mentioning up to ten key discussion topics.
## create_sigma_rules
Extracts Tactics, Techniques, and Procedures (TTPs) from security news publications to create YAML-based Sigma rules for host-based detection. These rules focus on detecting cybersecurity threats using tools like Sysinternals: Sysmon, PowerShell, and Windows logs. The output includes well-documented Sigma rules in YAML format, each separated by headers and footers.
## create_stride_threat_model
The prompt instructs on creating a detailed threat model using the STRIDE per element methodology for a given system design document. It emphasizes understanding the system's assets, trust boundaries, and data flows to identify and prioritize potential threats. The expected output is a comprehensive table listing threats, their components, mitigation strategies, and risk assessments.
The prompt instructs on creating a detailed threat model using the STRIDE per element methodology for a given system design document. It emphasizes understanding the system's assets, trust boundaries, and data flows to identify and prioritize potential threats. The expected output is a comprehensive table categorizing threats, their mitigation strategies, and assessing their risk severity.
## create_summary
Summarizes content into a structured Markdown format, focusing on brevity and clarity. It emphasizes creating a concise summary, listing main points, and identifying key takeaways. The output is organized into specific sections for easy reference.
The prompt instructs on summarizing content into a structured Markdown format. It emphasizes creating concise, informative summaries with specific sections for a one-sentence summary, main points, and key takeaways. The expected output is a neatly organized summary with clear, distinct sections.
## create_tags
The prompt instructs to identify and output tags from text content for use in mind mapping tools, focusing on extracting at least five subjects or ideas. It emphasizes including any authors or existing tags, converting spaces in tags to underscores, and ensuring all tags are in lowercase without repetition. The expected output is a single line of space-separated, lowercase tags relevant to the text's content.
## create_threat_model
The prompt outlines a comprehensive approach to everyday threat modeling, emphasizing its application beyond technical defenses to include personal and physical security scenarios. It distinguishes between realistic and possible threats, advocating for a balanced approach to risk management that considers the value of what's being protected, the likelihood of threats, and the cost of controls. The expected output involves creating threat models for various scenarios, highlighting realistic defenses, and guiding individuals towards logical security decisions through structured analysis.
The prompt instructs on creating narrative-based threat models for various scenarios, emphasizing realistic risk assessment over improbable dangers. It highlights the importance of distinguishing between possible and likely threats, focusing defense efforts on the latter. The expected output includes a structured threat model and an analysis section guiding logical defense choices against identified scenarios.
## create_threat_scenarios
The prompt seeks to identify and prioritize potential threats to a given system or situation, using a narrative-based, simple threat modeling approach. It emphasizes distinguishing between realistic and possible threats, focusing on those worth defending against. The expected output includes a list of prioritized threat scenarios, an analysis of the threat model, recommended controls, a narrative analysis, and a concise conclusion.
The prompt aims to create narrative-based, simple threat models for various security concerns, ranging from physical to cybersecurity. It emphasizes a realistic approach to identifying and prioritizing potential threats based on likelihood and impact. The expected output includes a detailed analysis of threat scenarios, a logical explanation of the threat modeling process, recommended controls, and a narrative analysis that injects realism into the assessment of risks.
## create_upgrade_pack
Extracts and organizes insights on world models and task algorithms from provided content. It focuses on identifying and categorizing beliefs about the world and optimal task execution strategies. The output includes concise, actionable bullet points under relevant categories.
The prompt instructs on extracting and updating world models and task algorithms from given content. It emphasizes deep thinking to identify beliefs about the world and how tasks should be performed. The expected output includes concise bullet points summarizing these beliefs and task strategies, organized into relevant categories.
## create_video_chapters
Extracts and organizes the most engaging topics from a transcript with corresponding timestamps. This process involves a detailed review of the transcript to identify key moments and subjects. The output is a list of topics with their timestamps in a sequential format.
Extracts and timestamps the most interesting topics from a transcript, simulating the experience of watching the video. It focuses on identifying key subjects and moments, then matching them with precise timestamps. The output is a list of topics with sequential timestamps within the video's length.
## create_visualization
Transforms complex ideas into simplified ASCII art visualizations. This approach focuses on distilling intricate concepts into visual forms that can be easily understood through ASCII art. The expected output is a detailed ASCII art representation accompanied by a concise visual explanation.
Transforms complex ideas into simplified ASCII art visualizations. This approach allows for intricate concepts to be understood visually through detailed ASCII diagrams. The output is a standalone ASCII art piece, accompanied by a concise visual explanation.
## explain_code
Analyzes and explains code, security tool outputs, or configuration texts, tailoring the explanation to the type of input. It uses specific sections to clarify the function, implications, or settings based on the input's nature. The expected output is a detailed explanation or answer in designated sections.
The prompt instructs an expert coder to analyze and explain code, security tool outputs, or configuration texts. It emphasizes a flexible approach to achieving the best explanation. The expected output is categorized explanations or answers to specific questions, tailored to the type of input provided.
## explain_docs
The prompt instructs on transforming input about tool usage into improved, structured documentation. It emphasizes clarity and utility, breaking down the process into specific sections for a comprehensive guide. The expected output includes an overview, usage syntax, common use cases, and key features of the tool.
Improves instructions for using tools or products by providing a structured format. This approach breaks down the explanation into what the tool does, why it's useful, how to use it, common use cases, and key features. The expected output includes simplified, better-organized instructions.
## explain_project
Summarizes project documentation into a concise, user and developer-focused summary, highlighting its purpose, problem addressed, approach, installation, usage, and examples. It simplifies complex information for easy understanding and application. The output includes a project overview, problem it addresses, approach to solving the problem, and practical steps for installation and usage.
The prompt instructs on summarizing project documentation into a structured, user-friendly format. It emphasizes understanding the project, then distilling this understanding into concise summaries and practical steps for installation and usage. The output includes a project overview, problem addressed, approach to solving the problem, and clear instructions for installation and usage, all aimed at making the project accessible to users and developers.
## explain_terms
Produces a glossary of advanced terms found in specific content, including definitions and analogies. It focuses on explaining obscure or complex terms to aid understanding. The output is a list of terms with explanations and analogies in a structured Markdown format.
The prompt aims to create glossaries for complex terms within a given content, enhancing comprehension. It focuses on identifying and explaining advanced terms, excluding basic ones, to aid in understanding the content. The expected output is a list of advanced terms with definitions, analogies, and their significance, formatted in Markdown.
## export_data_as_csv
The prompt instructs the AI to identify and format data structures from the input into a CSV file. It emphasizes understanding the context and accurately naming fields based on the input. The expected output is a CSV file containing all identified data structures.
## extract_algorithm_update_recommendations
Analyzes input to provide concise recommendations for improving processes. It focuses on extracting actionable advice from content descriptions. The output consists of a bulleted list of up to three brief suggestions.
Analyzes input to provide concise, actionable recommendations for improving processes within content. It focuses on extracting practical steps to enhance algorithms or methodologies. The output consists of a bulleted list of up to three brief suggestions.
## extract_article_wisdom
Extracts key insights and valuable information from textual content, focusing on ideas, quotes, habits, and references. It aims to address the issue of information overload by providing a concise summary of the content's most meaningful aspects. The expected output includes summarized ideas, notable quotes, referenced materials, and habits worth adopting.
Extracts key insights and wisdom from textual content, aiming to address the issue of information overload and the challenge of retaining valuable information. It uniquely identifies and organizes ideas, quotes, references, habits, and recommendations from a wide range of texts. The expected output includes summarized ideas, notable quotes, relevant references, and actionable habits.
## extract_book_ideas
Summarizes a book's key content by extracting 50 to 100 of its most interesting ideas. The process involves a deep dive into the book's insights, prioritizing them by interest and insightfulness. The output is a concise list of bulleted ideas, limited to 20 words each.
Summarizes a book's key content by extracting 50 to 100 of its most insightful, surprising, and interesting ideas. The process involves a deep recall of the book's details, prioritizing the ideas by their impact. The output is formatted as a bulleted list, limited to 20 words per idea.
## extract_book_recommendations
Summarizes a book's key content by extracting 50 to 100 of its most practical recommendations, prioritizing the most impactful advice. This process involves a thorough memory search to identify actionable insights. The output is formatted as an instructive, bullet-pointed list, limited to 20 words each.
Summarizes a book's key content by extracting 50 to 100 of its most practical recommendations. The approach focuses on actionable advice, prioritizing the most impactful suggestions first. The output is a Markdown-formatted list of instructive recommendations, capped at 20 words each.
## extract_business_ideas
The prompt outlines a process for identifying and elaborating on innovative business ideas. It focuses on extracting top business concepts from provided content and then refining the best ten by exploring adjacent possibilities. The expected output includes two sections: a list of extracted ideas and a detailed elaboration on the top ten ideas, ensuring uniqueness and differentiation.
Extracts and elaborates on top business ideas from provided content, focusing on those with potential to revolutionize industries. This assistant first identifies all notable business concepts, then selects and expands on the ten most promising ones, ensuring uniqueness and differentiation. The output includes a list of extracted ideas and a detailed elaboration on the top ten.
## extract_controversial_ideas
Identifies and lists controversial statements from inputs. This AI system focuses on extracting contentious ideas and quotes, presenting them in a structured Markdown format. The expected output includes sections for controversial ideas and supporting quotes, each with specific content guidelines.
## extract_extraordinary_claims
Identifies and lists extraordinary claims from conversations, focusing on those rejected by the scientific community or based on misinformation. The process involves deep analysis to pinpoint statements that defy accepted scientific truths, such as denying evolution or the moon landing. The output is a detailed list of quotes, ranging from 50 to 100, showcasing these claims.
The prompt instructs to identify and list extraordinary claims from conversations, focusing on those rejected by the scientific community or based on misinformation. It emphasizes capturing statements that defy accepted scientific truths, such as evolution or the moon landing. The expected output is a detailed list of at least 50 to no more than 100 specific quotes showcasing these claims.
## extract_ideas
Extracts and condenses insightful ideas from text into 15-word bullet points focusing on life's purpose and human progress. This process emphasizes capturing unique insights on specified themes. The output consists of a list of concise, thought-provoking ideas.
This prompt extracts insightful and interesting information from text, focusing on life's purpose and human progress. It emphasizes creating concise bullet points to summarize key ideas. The expected output includes a list of insightful ideas, each precisely 15 words long.
## extract_insights
Extracts and condenses complex insights from text on profound topics into 15-word bullet points. This process emphasizes the extraction of nuanced, powerful ideas related to human and technological advancement. The expected output is a concise list of abstracted, insightful bullets.
The prompt instructs on extracting and summarizing powerful insights from text, focusing on life's purpose and human-technology interaction. It emphasizes creating concise, insightful bullet points from the content. The expected output is a list of abstracted, wise insights, each precisely 15 words long.
## extract_main_idea
Extracts and highlights the most crucial or intriguing idea from any given content. This prompt emphasizes a methodical approach to identify and articulate the essence of the input. The expected output includes a concise main idea and a recommendation based on that idea.
The prompt instructs on extracting and presenting the most significant idea from any given content. It emphasizes a structured approach to identify and recommend actions based on the extracted idea. The expected output includes a concise main idea and recommendation, each in a 15-word sentence.
## extract_patterns
The prompt guides in identifying and analyzing recurring, surprising, or insightful patterns from a collection of ideas, data, or observations. It emphasizes extracting the most notable patterns based on their frequency and significance, and then documenting the process of discovery and analysis. The expected output includes a detailed summary of patterns, an explanation of their selection and significance, and actionable advice for startup builders based on these insights.
The prompt instructs on identifying and analyzing patterns from a collection of ideas, data, or observations, focusing on those that are most surprising or frequently mentioned. It outlines a structured approach to extract, weigh, and document these patterns, including a detailed analysis and advice for builders in the startup space. The expected output includes sections for patterns, meta-analysis, a summary analysis, the top five patterns, and advice for builders, all formatted as bullet points with specific word limits.
## extract_poc
Analyzes security or bug bounty reports to extract and provide proof of concept URLs for validating vulnerabilities. It specializes in identifying actionable URLs and commands from the reports, ensuring direct verification of reported vulnerabilities. The output includes the URL with a specific command to execute it, like using curl or python.
Analyzes security or bug bounty reports to extract and provide proof of concept URLs for validating vulnerabilities. It uniquely identifies URLs that can directly verify the existence of vulnerabilities, accompanied by the necessary command to execute them. The output includes a command followed by the URL or file to validate the vulnerability.
## extract_predictions
Extracts and organizes predictions from content into a structured format. It focuses on identifying specific predictions, their timelines, confidence levels, and verification methods. The expected output includes a bulleted list and a detailed table of these predictions.
The prompt instructs on extracting and organizing predictions from given content. It details a process for identifying specific predictions, their expected fulfillment dates, confidence levels, and verification methods. The expected output includes a bulleted list of predictions and a structured table summarizing these details.
## extract_questions
Extracts questions from content and analyzes their effectiveness in eliciting high-quality responses. It focuses on identifying the elements that make these questions particularly insightful. The expected output includes a list of questions, an analysis of their strengths, and recommendations for interviewers.
Extracts questions from content and analyzes their effectiveness in eliciting surprising, high-quality answers. It focuses on identifying the elements that make these questions outstanding. The output includes listed questions, an analysis of their brilliance, and recommendations for interviewers.
## extract_recommendations
Extracts and condenses recommendations from content into a concise list. This process involves identifying both explicit and implicit advice within the given material. The output is a bulleted list of up to 20 brief recommendations.
Extracts and condenses practical recommendations from content into a concise list. This process involves identifying explicit and implicit advice within the material. The output consists of a bulleted list of up to 20 brief recommendations.
## extract_references
Extracts references to various forms of cultural and educational content from provided text. This process involves identifying and listing references to art, literature, and academic papers concisely. The expected output is a bulleted list of up to 20 references, each summarized in no more than 16 words.
Extracts references to various forms of art and literature from content, compiling them into a concise list. This process involves identifying and listing up to 20 references, ensuring each is succinctly described in no more than 15 words. The output is a bulleted list of references to art, stories, books, literature, papers, and other sources of learning.
## extract_song_meaning
Analyzes and interprets the meaning of songs based on extensive research and lyric examination. This process involves deep analysis of the artist's background, song context, and lyrics to deduce the song's essence. Outputs include a summary sentence, detailed meaning in bullet points, and evidence supporting the interpretation.
Analyzes and interprets the meaning of songs based on lyrics, artist context, and other relevant information. This process involves extensive research and deep analysis of the lyrics. The output includes a summary sentence, detailed bullet points on the song's meaning, and evidence supporting the interpretation.
## extract_sponsors
Identifies and distinguishes between official and potential sponsors from transcripts. This process involves analyzing content to separate actual sponsors from merely mentioned companies. The output lists official sponsors and potential sponsors based on their mention in the content.
Identifies and categorizes sponsors and potential sponsors from transcripts. It discerns between actual sponsors and mere mentions, aiming for accurate sponsor identification. The output lists official and potential sponsors with descriptions and links.
## extract_videoid
Extracts video IDs from URLs for use in other applications. It meticulously analyzes the URL to isolate the video ID. The output is solely the video ID, with no additional information or errors included.
Extracts video IDs from URLs for use in other applications. It meticulously analyzes the URL to locate the specific part that contains the video ID. The output is solely the video ID, with no additional information or formatting.
## extract_wisdom
Extracts key insights, ideas, quotes, habits, and references from textual content to address the issue of information overload and the challenge of retaining knowledge. It uniquely filters and condenses valuable information from various texts, making it easier for users to decide if the content warrants a deeper review or to use as a note-taking alternative. The output includes summarized ideas, notable quotes, relevant habits, and useful references, all aimed at enhancing understanding and retention.
Extracts key insights from textual content to address the issue of information overload and memory retention. It uniquely identifies ideas, quotes, references, habits, and recommendations from a wide range of texts. The output includes summarized content, highlighting valuable takeaways and actionable items.
## extract_wisdom_agents
This prompt outlines a complex process for extracting insights from text content, focusing on themes like the meaning of life and technology's impact on humanity. It involves creating teams of AI agents with diverse expertise to analyze the content and produce summaries, ideas, insights, quotes, habits, facts, references, and recommendations. The expected output includes structured sections filled with concise, insightful entries derived from the input material.
The prompt outlines a complex process for extracting insights from text content, focusing on themes like the meaning of life and technology's impact on humanity. It describes creating teams of AI agents with diverse expertise to summarize content, identify key ideas, insights, quotes, habits, facts, references, and recommendations, and distill a one-sentence takeaway. The expected output includes summaries and lists of insights and recommendations, all structured to highlight the most valuable aspects of the input material.
## extract_wisdom_dm
Extracts and synthesizes valuable content from input text, focusing on insights related to life's purpose and human advancement. It employs a structured approach to distill surprising ideas, insights, quotes, habits, facts, and recommendations from the content. The output includes summaries, ideas, insights, and other categorized information for deep understanding and practical application.
The prompt outlines a comprehensive process for extracting and organizing valuable content from input text, focusing on insights related to life's purpose, human flourishing, and technology's impact. It emphasizes a detailed, step-by-step approach to identify ideas, insights, quotes, habits, facts, references, and recommendations from the content. The expected output includes summaries, lists of ideas, insights, quotes, habits, facts, references, and a one-sentence takeaway, all formatted in Markdown and adhering to specific word counts and item quantities.
## extract_wisdom_large
The purpose is to extract and distill key insights, ideas, habits, facts, and recommendations from a detailed conversation about writing, communication, and the iterative process of creating content. The nuanced approach involves identifying the essence of effective communication, the importance of authenticity in writing, and the value of distillation in conveying ideas. The expected output includes categorized summaries of ideas, insights, habits, facts, recommendations, and more, all aimed at enhancing understanding and application of the discussed principles in writing and communication.
## extract_wisdom_nometa
This prompt guides the extraction and organization of insightful content from text, focusing on life's purpose, human flourishing, and technology's impact. It emphasizes identifying and summarizing surprising ideas, refined insights, practical habits, notable quotes, valid facts, and useful recommendations related to these themes. The expected output includes structured sections for summaries, ideas, insights, quotes, habits, facts, recommendations, and references, each with specific content and formatting requirements.
The prompt instructs on extracting and organizing various insights, ideas, quotes, habits, facts, recommendations, and references from text content focused on life's purpose, human flourishing, and the impact of technology and AI. It emphasizes the discovery of surprising and insightful information within these themes. The output is structured into sections for summary, ideas, insights, quotes, habits, facts, references, and recommendations, with specific instructions on the length and format for each entry.
## find_hidden_message
Analyzes political messages to reveal overt and hidden intentions. It employs knowledge of politics, propaganda, and psychology to dissect content, focusing on recent political debates. The output includes overt messages, hidden cynical messages, supporting arguments, desired audience actions, and analyses from cynical to favorable.
The prompt instructs the AI to analyze and interpret political messages in content, distinguishing between overt and hidden messages. It emphasizes a cynical evaluation, focusing on underlying political intentions and expected actions from the audience. The output includes structured analysis and summaries of both overt and hidden messages, supported by arguments and desired audience actions, concluding with various levels of analysis from cynical to favorable.
## find_logical_fallacies
Identifies and categorizes various fallacies in arguments or texts. This prompt focuses on recognizing invalid or faulty reasoning across a wide range of fallacies, from formal to informal types. The expected output is a list of identified fallacies with brief explanations.
The prompt instructs the AI to identify various types of fallacies from a given text, using a comprehensive list of fallacies as a reference. It emphasizes the importance of recognizing invalid or faulty reasoning in arguments. The expected output is a list of identified fallacies, each described concisely within a 15-word explanation, formatted under a "FALLACIES" section in Markdown.
## get_wow_per_minute
Evaluates the density of wow-factor in content by analyzing its surprise, novelty, insight, value, and wisdom. This process involves a detailed and varied consumption of the content to assess its potential to engage and enrich viewers. The expected output is a JSON report detailing scores and explanations for each wow-factor component and overall wow-factor per minute.
Evaluates the density of wow-factor in content, focusing on surprise, novelty, insight, value, and wisdom across various content types. It aims to quantify how rewarding content is based on these elements. The expected output is a JSON file detailing scores and explanations for each wow-factor component per minute.
## get_youtube_rss
Generates RSS URLs for YouTube channels based on given channel IDs or URLs. It extracts the channel ID from the input and constructs the corresponding RSS URL. The output is solely the RSS URL.
## improve_academic_writing
This prompt aims to enhance the quality of text for academic purposes. It focuses on refining grammatical errors, improving clarity and coherence, and adopting an academic tone while ensuring ease of understanding. The expected output is a professionally refined text with a list of applied corrections.
This prompt aims to refine input text into an academic and scientific language, ensuring clarity, coherence, and ease of understanding. It emphasizes the use of formal English, avoiding repetition and trivial statements for a professional tone. The expected output is a text improved for academic purposes.
## improve_prompt
This service enhances LLM/AI prompts by applying expert prompt writing techniques to achieve better results. It leverages strategies like clear instructions, persona adoption, and reference text provision to refine prompts. The output is an improved version of the original prompt, optimized for clarity and effectiveness.
Enhances LLM/AI prompt quality by applying expert writing techniques, focusing on clarity, specificity, and structured instructions. It leverages strategies like clear instructions, persona adoption, and reference text provision to improve model responses. The service outputs refined prompts designed for optimal interaction with LLMs.
## improve_report_finding
The prompt instructs the creation of an improved security finding report from a penetration test, detailing the finding, risk, recommendations, references, a concise summary, and insightful quotes, all formatted in markdown without using markdown syntax or special formatting. It emphasizes a detailed, insightful approach to presenting cybersecurity issues and solutions. The output should be comprehensive, covering various sections including title, description, risk, recommendations, references, and quotes, aiming for clarity and depth in reporting.
Improves a security finding from a penetration test report by providing a detailed and enhanced report in markdown format, focusing on description, risk, recommendations, references, and summarizing the finding concisely. It emphasizes clarity, insightfulness, and actionable advice while avoiding jargon and repetition. The output includes a title, detailed description, risk analysis, insightful recommendations, relevant references, a concise summary, and notable quotes, all formatted for easy readability and immediate application.
## improve_writing
This prompt aims to refine input text for enhanced clarity, coherence, grammar, and style. It involves analyzing the text for errors and inconsistencies, then applying corrections while preserving the original meaning. The expected output is a grammatically correct and stylistically improved version of the text.
This prompt aims to refine and enhance input text for better clarity, coherence, grammar, and style. It involves analyzing the text for errors and inconsistencies, then applying corrections while preserving the original meaning. The expected output is a grammatically correct and stylistically improved version of the input text.
## label_and_rate
Evaluates and categorizes content based on its relevance to specific human-centric themes, then assigns a tiered rating and a numerical quality score. It uses a predefined set of labels for categorization and assesses content based on idea quantity and thematic alignment. The expected output is a structured JSON object detailing the content summary, labels, rating, and quality score with explanations.
The prompt outlines a process for evaluating content based on its relevance to specific human-centric themes, assigning labels from a predefined list, and rating its quality and thematic alignment. It emphasizes the importance of content's focus on human flourishing and meaning, penalizing content that is politically charged or unrelated to the core themes. The expected output is a structured JSON object summarizing the content's essence, its applicable labels, a tiered rating, and a numerical quality score, along with explanations for these assessments.
## official_pattern_template
The prompt outlines a complex process for diagnosing and addressing psychological issues based on a person's background and behaviors. It involves deep analysis of the individual's history, identifying potential mental health issues, and suggesting corrective actions. The expected output includes summaries of past events, possible psychological issues, their impact on behavior, and recommendations for improvement.
Analyzes a person's background and behaviors to diagnose psychological issues and recommend actions. It involves a detailed process of understanding the individual's history and current behavior to identify underlying problems. The output includes summaries of events, possible issues, behavior connections, and corrective recommendations.
## philocapsulate
Summarizes teachings of philosophers or philosophies, providing detailed templates on their background, encapsulated philosophy, school, teachings, works, quotes, application, and life advice. It differentiates between individual philosophers and philosophies with tailored templates for each. The output includes structured information for educational or analytical purposes.
The prompt instructs on creating detailed templates about philosophers or philosophies, including their background, teachings, and application. It specifies the structure for presenting information, such as encapsulating philosophies, listing works or teachings, and defining terms like "$philosopher-ian." The expected output is a comprehensive overview tailored to either an individual philosopher or a philosophy, highlighting key aspects and advice on living according to their teachings.
## provide_guidance
Provides comprehensive psychological advice tailored to the individual's specific question and context. This approach delves into the person's past, traumas, and life goals to offer targeted feedback and recommendations. The expected output includes a concise analysis, detailed scientific rationale, actionable recommendations, Esther Perel's perspective, self-reflection prompts, possible clinical diagnoses, and a summary, all aimed at fostering self-awareness and positive change.
Provides comprehensive psychological advice tailored to the individual's specific question and context. This approach combines elements of psychiatry, psychology, and life coaching, offering a structured analysis and actionable recommendations. The expected output includes a concise analysis, detailed scientific explanations, personalized recommendations, and self-reflection questions.
## rate_ai_response
Evaluates the quality of AI responses against the benchmark of human experts, assigning a letter grade and score. It involves deep analysis of both the instructions given to the AI and its output, comparing these to the potential performance of the world's best human expert. The process culminates in a detailed justification for the assigned grade, highlighting specific strengths and weaknesses of the AI's response.
Evaluates the quality of AI responses against the benchmark of the world's best human experts, focusing on understanding instructions, comparing AI output to optimal human performance, and rating the AI's work using a detailed grading system. The process involves deep analysis of both the instructions given to the AI and its response, followed by a structured evaluation that includes a letter grade, specific reasons for the grade, and a numerical score. The evaluation criteria emphasize comparison with human capabilities, ranging from expert to average performance.
## rate_ai_result
Evaluates the quality of AI-generated content based on construction, quality, and spirit. The process involves analyzing AI outputs against criteria set by experts and a high-IQ AI panel. The expected output is a final score out of 100, with deductions detailed for each category.
Evaluates the quality of AI-generated content based on construction, quality, and spirit. This process involves analyzing AI outputs against criteria set by experts and a high-IQ AI panel. The final output is a comprehensive score out of 100, reflecting the content's adherence to the prompt's requirements and essence.
## rate_content
The prompt outlines a process for evaluating content by labeling it with relevant single-word descriptors, rating its quality based on idea quantity and thematic alignment, and scoring it on a scale from 1 to 100. It emphasizes the importance of matching content with specific themes related to human meaning and the future of AI, among others. The expected output includes a list of labels, a tiered rating with an explanation, and an overall quality score with justification.
The prompt outlines a process for evaluating content by labeling it with relevant single-word descriptors and then rating its quality based on idea quantity and thematic alignment with specified themes. It emphasizes a nuanced approach to content assessment, combining quantitative and qualitative measures. The expected output includes a list of labels, a tiered rating with an explanation, and a numerical content score with justification.
## rate_value
This prompt seeks to acknowledge the collaborative effort behind its creation, inspired by notable figures in information theory and viral content creation. It highlights the fusion of theoretical foundations and modern digital strategies. The output is an attribution of credit.
The prompt aims to create content inspired by Claude Shannon's Information Theory and Mr. Beast's viral techniques. It leverages foundational communication theories and modern viral strategies for impactful content creation. The expected output is engaging and widely shareable content.
## raw_query
The prompt instructs the AI to produce the best possible output by thoroughly analyzing and understanding the input. It emphasizes deep contemplation of the input's meaning and the sender's intentions. The expected output is an optimal response tailored to the inferred desires of the input provider.
The prompt instructs the AI to produce the best possible output by thoroughly analyzing and understanding the input. It emphasizes deep contemplation of the input's meaning and the sender's intentions. The expected output is an optimal response tailored to the perceived desires of the prompt sender.
## recommend_artists
Recommends a personalized festival schedule featuring artists similar to the user's preferences in EDM genres and artists. The recommendation process involves analyzing the user's favorite styles and artists, then selecting similar artists and explaining the choices. The output is a detailed schedule organized by day, set time, stage, and artist, optimized for the user's enjoyment.
Recommends a personalized festival schedule featuring artists that match the user's preferred EDM styles and artists. The process involves analyzing the user's favorite styles and artists, then selecting similar artists and explaining the choices. The output is a day-by-day, set-time, and stage schedule optimized for the user's enjoyment.
## show_fabric_options_markmap
Create a visual representation of the functionalities provided by the Fabric project, focusing on augmenting human capabilities with AI. The approach involves breaking down the project's capabilities into categories like summarization, analysis, and more, with specific patterns branching from these categories. The expected output is comprehensive Markmap code detailing this functionality map.
Summarizes the Fabric project, an open-source framework designed to integrate AI into daily challenges through customizable prompts called Patterns. It emphasizes ease of use and adaptability, offering tools for a wide range of tasks from content summarization to creating AI art. The expected output includes a visual Markmap representation of Fabric's capabilities.
## suggest
Analyzes user input to suggest appropriate fabric commands or patterns, enhancing the tool's functionality. It involves understanding specific needs, determining suitable commands, and providing clear, user-friendly suggestions. The output includes command suggestions, explanations, and instructions for new patterns.
## suggest_pattern
Develops a feature for a fabric command-line tool to suggest appropriate commands or patterns based on user input. It involves analyzing requests, determining suitable commands, and providing clear suggestions. The output includes explanations or multiple options, aiming to enhance user accessibility.
## summarize
Summarizes content into a structured Markdown format, focusing on brevity and clarity. It extracts and lists the most crucial points and takeaways. The output includes a one-sentence summary, main points, and key takeaways, adhering to specified word limits.
The prompt instructs on summarizing content into a structured Markdown format. It emphasizes creating concise, informative summaries with specific sections for a one-sentence summary, main points, and key takeaways. The expected output is a neatly organized summary with clear, distinct sections.
## summarize_debate
Analyzes debates to identify and summarize the primary disagreements, arguments, and evidence that could change participants' minds. It breaks down complex discussions into concise summaries and evaluates argument strength, predicting outcomes. The output includes structured summaries and analyses of each party's position and evidence.
The prompt outlines a process for analyzing debates, focusing on identifying disagreements, arguments, and evidence that could change participants' minds. It emphasizes a structured approach to summarizing debates, including extracting key points and evaluating argument strength. The expected output includes summaries of the content, arguments, and evidence, along with an analysis of argument strength and predictions about the debate's outcome.
## summarize_git_changes
Summarizes major changes and upgrades in a GitHub project over the past week. It involves identifying key updates, then crafting a concise, enthusiastic summary and detailed bullet points highlighting these changes. The output includes a 20-word introduction and excitedly written update bullets.
Summarizes major changes and upgrades in a GitHub project over the past week. The approach involves creating a concise section titled "CHANGES" with bullet points limited to 10 words each. The expected output includes a 20-word introductory sentence and bullet points detailing the updates enthusiastically.
## summarize_git_diff
Analyzes Git diffs to summarize major changes and upgrades. It emphasizes creating concise bullet points for feature changes and updates, tailored to the extent of modifications. The expected output includes a 100-character intro sentence using conventional commits format.
Analyzes Git diffs to identify and summarize key changes and upgrades. This prompt focuses on creating concise, bullet-point summaries for project updates, using conventional commit messages. The expected output includes a brief intro sentence followed by bullet points detailing the changes.
## summarize_lecture
Extracts and organizes key topics from a lecture transcript, providing structured summaries, definitions, and timestamps. This process involves a detailed review of the transcript to identify main subjects, create bullet points, and list definitions with corresponding video timestamps. The output includes a concise summary, a list of tools mentioned with descriptions, and a one-sentence takeaway, all formatted for easy readability.
## summarize_micro
Summarizes content into a structured Markdown format. This prompt focuses on concise, bullet-pointed summaries and takeaways. The output includes a one-sentence summary and lists of main points and takeaways.
The prompt instructs on summarizing content into a structured Markdown format. It emphasizes conciseness and clarity, focusing on a single sentence summary, main points, and key takeaways. The expected output is a well-organized, bullet-pointed list highlighting the essence of the content.
## summarize_newsletter
Extracts and organizes key content from newsletters, focusing on the most meaningful, interesting, and useful information. It uniquely parses the entire newsletter to provide concise summaries, lists of content, opinions, tools, companies, and follow-up actions. The output includes sections for a brief summary, detailed content points, author opinions, mentioned tools and companies, and recommended follow-ups in a structured Markdown format.
Extracts and organizes key content from newsletters into a structured, easy-to-navigate format. It focuses on summarizing, categorizing, and highlighting essential information, including opinions, tools, and companies mentioned. The output is a comprehensive breakdown of the newsletter's content for quick reference.
## summarize_paper
Summarizes academic papers by extracting key sections such as title, authors, main goals, and more from the provided text. It employs a structured approach to highlight the paper's core aspects including technical methodology, distinctive features, and experimental outcomes. The output is a detailed summary covering various dimensions of the research.
Generates a summary of an academic paper from its full text, focusing on key sections like title, authors, main goals, and findings. It uniquely structures the output into specific categories for clarity. The expected output includes sections on the paper's title, authors, main goal, technical approach, distinctive features, experimental results, advantages, limitations, and conclusion.
## summarize_pattern
This prompt instructs on summarizing AI chat prompts into concise paragraphs. It emphasizes using active voice and present tense for clarity. The expected output is a structured summary highlighting the prompt's purpose, approach, and anticipated results.
## summarize_prompt
This prompt instructs on summarizing AI chat prompts concisely. It emphasizes using active voice and present tense for clarity. The expected output is a succinct paragraph detailing the prompt's purpose, approach, and anticipated result.
## summarize_pull-requests
Summarizes pull requests for a coding project, focusing on the types of changes made. It involves creating a summary and a detailed list of main PRs, rewritten for clarity. The output includes a concise overview and specific examples of pull requests.
The prompt instructs on summarizing pull requests for a coding project, focusing on creating a summary and detailing top pull requests in a readable format. It emphasizes rewriting pull request items for clarity. The expected output includes a brief overview of the pull requests' nature and a list of major ones, rewritten for readability.
## summarize_rpg_session
This prompt outlines the process for summarizing in-person role-playing game sessions, focusing on key events, combat details, character development, and worldbuilding. It emphasizes capturing the essence of the session in a structured format, including summaries, lists, and descriptions to encapsulate the narrative and gameplay dynamics. The expected output includes a comprehensive overview of the session's storyline, character interactions, and significant moments, tailored for both players and observers.
Summarizes in-person role-playing game sessions, focusing on key events, combat details, character development, and worldbuilding. It transforms RPG transcripts into structured summaries, highlighting significant moments and character evolution. The output includes a heroic summary, detailed combat stats, MVPs, key discussions, character flaws, changes, quotes, humor, and worldbuilding insights.
## to_flashcards
Creates Anki cards from texts following specific principles to ensure simplicity, optimized wording, and no reliance on external context. This approach aims to enhance learning efficiency and comprehension without requiring prior knowledge of the text. The expected output is a set of questions and answers formatted as a CSV table.
Creates Anki cards from texts, adhering to principles of minimal information, optimized wording, and no external context. This approach ensures simplicity without losing essential details, aiming for quick and accurate recall. The output is a set of questions and answers formatted as a CSV table.
## tweet
Guides users on crafting engaging tweets with emojis, focusing on Twitter's basics and content creation strategies. It emphasizes understanding Twitter, identifying the target audience, and using emojis effectively. The expected output is a comprehensive guide for creating appealing tweets with emojis.
Guides users on crafting engaging tweets with emojis, starting from understanding Twitter basics to analyzing tweet performance. It emphasizes concise messaging, audience engagement, and the strategic use of emojis for personality and clarity. The expected output is enhanced tweeting skills and better audience interaction.
## write_essay
The task is to write an essay in the style of Paul Graham, focusing on the essence and approach of writing concise, clear, and illuminating essays on any given topic.
The purpose of this prompt is to generate an essay in the style of Paul Graham, focusing on a given topic while emulating his clear, simple, and conversational writing style. The essay should avoid cliches, jargon, and journalistic language, presenting ideas in a straightforward manner without common concluding phrases.
## write_hackerone_report
Assists bug bounty hunters in writing reports for HackerOne by analyzing requests, responses, and comments to generate a structured report. It leverages the `bbReportFormatter` tool for formatting inputs, facilitating dynamic, plugin-integrated, or command-line report generation. The output is a HackerOne-ready report that can be fine-tuned with additional details.
## write_micro_essay
The task is to write an essay in the style of Paul Graham, focusing on the essence of simplicity in conveying complex ideas.
The purpose of this prompt is to generate an essay in the style of Paul Graham, focusing on the topic provided, using a simple, clear, and conversational style. The essay should avoid cliches, jargon, and journalistic language, aiming for a publish-ready piece that reflects Graham's approach to writing. The content should be concise, limited to 250 words, and exclude common concluding phrases or setup language.
## write_nuclei_template_rule
The purpose of this prompt is to guide the creation of Nuclei templates for cybersecurity applications, focusing on generating precise and efficient scanning templates for various protocols like HTTP, DNS, TCP, and more. It emphasizes the importance of incorporating elements such as matchers, extractors, and conditions to tailor the templates for detecting specific vulnerabilities or configurations. The expected output is a well-structured YAML Nuclei template that adheres to best practices in template creation, including handling dynamic data extraction, utilizing complex matchers, and ensuring accurate vulnerability detection with minimal false positives.
```yaml
id: vhost-enum-flow
info:
name: vhost enum flow
author: tarunKoyalwar
severity: info
description: |
vhost enumeration by extracting potential vhost names from ssl certificate.
flow: |
ssl();
for (let vhost of iterate(template["ssl_domains"])) {
set("vhost", vhost);
http();
}
ssl:
- address: "{{Host}}:{{Port}}"
http:
- raw:
- |
GET / HTTP/1.1
Host: {{vhost}}
matchers:
- type: dsl
dsl:
- status_code != 400
- status_code != 502
extractors:
- type: dsl
dsl:
- '"VHOST: " + vhost + ", SC: " + status_code + ", CL: " + content_length'
```
## write_pull-request
The prompt instructs on drafting a detailed pull request (PR) description based on the output of a `git diff` command, focusing on identifying and explaining code changes. It emphasizes analyzing changes, understanding their purpose, and detailing their impact on the project. The expected output is a structured PR description in markdown, covering a summary of changes, reasons, impacts, and testing plans in clear language.
The prompt instructs a software engineer to draft a detailed pull request description based on the output of a `git diff` command, which compares changes between the current branch and the main repository branch. It emphasizes analyzing the changes, understanding their purpose, and clearly documenting them in markdown format, including summaries, reasons, impacts, and testing plans. The expected output is a structured PR description that concisely communicates the modifications and their implications for the project.
## write_semgrep_rule
The prompt requests the creation of a Semgrep rule to detect a specific vulnerability pattern in code, based on provided context and examples. It emphasizes the importance of crafting a rule that is general enough to catch any instance of the described vulnerability, rather than being overly specific to the given examples. The expected output is a well-structured Semgrep rule that aligns with the syntax and guidelines detailed in the context, capable of identifying the vulnerability across different scenarios.
The prompt requests the creation of a Semgrep rule to detect a specific vulnerability pattern in code, based on provided context and examples. It emphasizes the importance of capturing the general case of the vulnerability rather than focusing solely on the specific instances mentioned. The expected output is a well-structured Semgrep rule that aligns with the syntax and capabilities outlined in the detailed Semgrep rule syntax guide, capable of identifying potential security issues in code.

View File

@@ -1 +1 @@
"1.4.130"
"1.4.131"

View File

@@ -0,0 +1,15 @@
package deepseek
import (
"github.com/danielmiessler/fabric/plugins/ai/openai"
)
func NewClient() (ret *Client) {
ret = &Client{}
ret.Client = openai.NewClientCompatible("DeepSeek", "https://api.deepseek.com", nil)
return
}
type Client struct {
*openai.Client
}

View File

@@ -107,7 +107,7 @@ func (o *PatternsEntity) getFromDB(name string) (ret *Pattern, err error) {
func (o *PatternsEntity) PrintLatestPatterns(latestNumber int) (err error) {
var contents []byte
if contents, err = os.ReadFile(o.UniquePatternsFilePath); err != nil {
err = fmt.Errorf("could not read unique patterns file. Pleas run --updatepatterns (%s)", err)
err = fmt.Errorf("could not read unique patterns file. Please run --updatepatterns (%s)", err)
return
}
uniquePatterns := strings.Split(string(contents), "\n")

View File

@@ -1,3 +1,23 @@
// to_pdf
//
// Usage:
// [no args] Read from stdin, write to output.pdf
// <file.tex> Read from .tex file, write to <file>.pdf
// <output.pdf> Read stdin, write to specified PDF
// <output> Read stdin, write to <output>.pdf
// <input> <output> Read input (.tex appended if needed), write to output.pdf
//
// Examples:
// to_pdf # stdin -> output.pdf
// to_pdf doc.tex # doc.tex -> doc.pdf
// to_pdf report # stdin -> report.pdf
// to_pdf chap.tex out/ # Creates out/chap.pdf
//
// Error handling:
// - Validates pdflatex installation
// - Creates missing directories
// - Cleans temp files on exit
package main
import (
@@ -9,23 +29,98 @@ import (
"strings"
)
// hasSuffix checks if a string ends with the given suffix, case-insensitive.
func hasSuffix(s, suffix string) bool {
return strings.HasSuffix(strings.ToLower(s), strings.ToLower(suffix))
}
// resolveInputFile attempts to open the input file.
// If tryAppendTex is true and the initial attempt fails, it appends ".tex" and retries.
func resolveInputFile(filename string, tryAppendTex bool) (io.ReadCloser, string) {
file, err := os.Open(filename)
if err == nil {
return file, filename
}
if tryAppendTex {
newFilename := filename + ".tex"
file, err = os.Open(newFilename)
if err == nil {
return file, newFilename
}
}
return nil, ""
}
func main() {
var input io.Reader
var outputFile string
if len(os.Args) > 1 {
// File input mode
file, err := os.Open(os.Args[1])
if err != nil {
fmt.Fprintf(os.Stderr, "Error opening file: %v\n", err)
args := os.Args
argCount := len(args) - 1 // excluding the program name
switch argCount {
case 0:
// Case 1: No arguments
input = os.Stdin
outputFile = "output.pdf"
case 1:
// Case 2: One argument
arg := args[1]
if hasSuffix(arg, ".tex") {
// Case 2a: Argument ends with .tex
file, actualName := resolveInputFile(arg, false)
if file == nil {
fmt.Fprintf(os.Stderr, "Error opening file: %s\n", arg)
os.Exit(1)
}
defer file.Close()
input = file
// Derive output file name by replacing .tex with .pdf
ext := filepath.Ext(actualName)
outputFile = strings.TrimSuffix(actualName, ext) + ".pdf"
} else if hasSuffix(arg, ".pdf") {
// Case 2b: Argument ends with .pdf
input = os.Stdin
outputFile = arg
} else {
// Case 2c: Argument without .pdf
input = os.Stdin
outputFile = arg + ".pdf"
}
case 2:
// Case 3: Two arguments
inputArg := args[1]
outputArg := args[2]
// Resolve input file, ignore actualName
file, _ := resolveInputFile(inputArg, true)
if file == nil {
fmt.Fprintf(os.Stderr, "Error: Input file '%s' not found, even after appending '.tex'.\n", inputArg)
os.Exit(1)
}
defer file.Close()
input = file
outputFile = strings.TrimSuffix(os.Args[1], filepath.Ext(os.Args[1])) + ".pdf"
} else {
// Stdin mode
input = os.Stdin
outputFile = "output.pdf"
// Resolve output file
if hasSuffix(outputArg, ".pdf") {
outputFile = outputArg
} else {
outputFile = outputArg + ".pdf"
}
default:
fmt.Fprintf(os.Stderr, "Usage:\n")
fmt.Fprintf(os.Stderr, " %s # Read from stdin, output to 'output.pdf'\n", args[0])
fmt.Fprintf(os.Stderr, " %s <file.tex> # Read from 'file.tex', output to 'file.pdf'\n", args[0])
fmt.Fprintf(os.Stderr, " %s <output.pdf> # Read from stdin, output to 'output.pdf'\n", args[0])
fmt.Fprintf(os.Stderr, " %s <output> # Read from stdin, output to '<output>.pdf'\n", args[0])
fmt.Fprintf(os.Stderr, " %s <input> <output># Read from 'input' (tries 'input.tex'), output to 'output.pdf'\n", args[0])
os.Exit(1)
}
// Check if pdflatex is installed
@@ -44,7 +139,8 @@ func main() {
defer os.RemoveAll(tmpDir)
// Create a temporary .tex file
tmpFile, err := os.Create(filepath.Join(tmpDir, "input.tex"))
tmpFilePath := filepath.Join(tmpDir, "input.tex")
tmpFile, err := os.Create(tmpFilePath)
if err != nil {
fmt.Fprintf(os.Stderr, "Error creating temporary file: %v\n", err)
os.Exit(1)
@@ -54,12 +150,13 @@ func main() {
_, err = io.Copy(tmpFile, input)
if err != nil {
fmt.Fprintf(os.Stderr, "Error writing to temporary file: %v\n", err)
tmpFile.Close()
os.Exit(1)
}
tmpFile.Close()
// Run pdflatex with nonstopmode
cmd := exec.Command("pdflatex", "-interaction=nonstopmode", "-output-directory", tmpDir, tmpFile.Name())
cmd := exec.Command("pdflatex", "-interaction=nonstopmode", "-output-directory", tmpDir, "input.tex")
output, err := cmd.CombinedOutput()
if err != nil {
fmt.Fprintf(os.Stderr, "Error running pdflatex: %v\n", err)
@@ -75,43 +172,25 @@ func main() {
os.Exit(1)
}
// Move the output PDF to the current directory
// Move the output PDF to the desired location
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
// Remove the generated PDF from the temporary directory
err = os.Remove(pdfPath)
if err != nil {
fmt.Fprintf(os.Stderr, "Error cleaning up temporary file: %v\n", err)
os.Exit(1)
// Not exiting as the main process succeeded
}
// Clean up temporary files
cleanupTempFiles(tmpDir)
fmt.Printf("PDF created: %s\n", outputFile)
}
func cleanupTempFiles(dir string) {
extensions := []string{".aux", ".log", ".out", ".toc", ".lof", ".lot", ".bbl", ".blg"}
for _, ext := range extensions {
files, err := filepath.Glob(filepath.Join(dir, "*"+ext))
if err != nil {
fmt.Fprintf(os.Stderr, "Error finding %s files: %v\n", ext, err)
continue
}
for _, file := range files {
if err := os.Remove(file); err != nil {
fmt.Fprintf(os.Stderr, "Error removing file %s: %v\n", file, err)
}
}
}
}
// Copy a file from source src to destination dst
// copyFile copies a file from src to dst.
// If dst exists, it will be overwritten.
func copyFile(src, dst string) error {
sourceFile, err := os.Open(src)
if err != nil {
@@ -119,6 +198,13 @@ func copyFile(src, dst string) error {
}
defer sourceFile.Close()
// Ensure the destination directory exists
dstDir := filepath.Dir(dst)
err = os.MkdirAll(dstDir, 0755)
if err != nil {
return err
}
destFile, err := os.Create(dst)
if err != nil {
return err

View File

@@ -44,6 +44,7 @@ func (h *ConfigHandler) GetConfig(c *gin.Context) {
"ollama": "",
"openrouter": "",
"silicon": "",
"deepseek": "",
})
return
}
@@ -63,6 +64,7 @@ func (h *ConfigHandler) GetConfig(c *gin.Context) {
"ollama": os.Getenv("OLLAMA_URL"),
"openrouter": os.Getenv("OPENROUTER_API_KEY"),
"silicon": os.Getenv("SILICON_API_KEY"),
"deepseek": os.Getenv("DEEPSEEK_API_KEY"),
}
c.JSON(http.StatusOK, config)
@@ -83,6 +85,7 @@ func (h *ConfigHandler) UpdateConfig(c *gin.Context) {
OllamaURL string `json:"ollama_url"`
OpenRouterApiKey string `json:"openrouter_api_key"`
SiliconApiKey string `json:"silicon_api_key"`
DeepSeekApiKey string `json:"deepseek_api_key"`
}
if err := c.BindJSON(&config); err != nil {
@@ -99,6 +102,7 @@ func (h *ConfigHandler) UpdateConfig(c *gin.Context) {
"OLLAMA_URL": config.OllamaURL,
"OPENROUTER_API_KEY": config.OpenRouterApiKey,
"SILICON_API_KEY": config.SiliconApiKey,
"DEEPSEEK_API_KEY": config.DeepSeekApiKey,
}
var envContent strings.Builder

View File

@@ -1,3 +1,3 @@
package main
var version = "v1.4.130"
var version = "v1.4.131"

View File

@@ -9,7 +9,7 @@ The goal of this app is to not only provide a user interface for Fabric, but als
## Installing
The app can be run by navigating to the `web` directory and using `npm install`, `pnpm install`, or your preferred package manager. Then simply run `npm run dev`, `pnpm run dev`, or your equivalent command to start the app. *You will need to run fabric in a seperate terminal with the `fabric --serve` command.*
The app can be run by navigating to the `web` directory and using `npm install`, `pnpm install`, or your preferred package manager. Then simply run `npm run dev`, `pnpm run dev`, or your equivalent command to start the app. *You will need to run fabric in a separate terminal with the `fabric --serve` command.*
## Tips

View File

@@ -103,7 +103,7 @@ Could this be the new component for the search bar?
</div>
<div>
<h4 class="h4"><b>Share Your Most Important Toughts and Ideas</b></h4>
<h4 class="h4"><b>Share Your Most Important Thoughts and Ideas</b></h4>
<br>
<Card
header="Let Your Voice Be Heard"