[Question]: I think I'm missing something, but Fabric doesn't seem to want to do anything I describe in a new pattern.

[mainlyetcetera]

What is your question?

When I use create_pattern to make a pattern, I describe generally what I want it to do, along with the output I'm looking for. It builds what looks like a decent pattern markdown file. I copy that over to .config/fabric/patterns/<name_of_pattern>/system.md. Seems like it should be ready to go, as checking fabric -l | grep <name> shows my pattern right there. I can call it with -p. However...

Fabric basically ignores the pattern, and runs as if I just ran it with a -s flag. It ignores any info I've told it to care about in the pattern. It completely ignores the output I'm looking for. I've done this with a couple patterns I'm trying to make for myself, and each time, it just seems to ignore me entirely.

Is there something else I need to do to get Fabric to respect new patterns? I hold onto them, also, in a personal_patterns' dir, and copy that over to patterns//system.md`, so I'm not afraid of losing them. But I'm tired of Fabric seeming to just give my new patterns the middle finger. What do you all think? I am pretty new to trying to adopt this, so am totally open to being told I'm doing it all wrong, but would appreciate some assistance from folks who've gotten their own patterns going. Please and thank you!

[ksylvan]

There should be nothing else you need to do. We need a lot more specifics to help you debug this.

I do the exact same thing in my custom fabric repo: https://github.com/ksylvan/custom-fabric

[mainlyetcetera]

hey all. coming back to this, and thank you @ksylvan for commenting.

so i want to run something else by you all, because i'm seeing some pretty wild variation with this. made a couple patterns since, and getting some variance when running. sometimes fabric runs my patterns just as intended. and... sometimes not. without me changing the patterns, i'm seeing fabric can give me wildly different output, and that can change from run to run.

i believe this is due to two things: the performance of my machine, and the models i'm choosing. i'm running fabric from my personal laptop. it's strong. 16 cores, 32 GB of memory. note, though: no gpu's. when i run something with fabric or anything else (open webui), then it takes about 25% of total cpu, maxes a couple cores, and after a little while, gives me its output. i'm not familiar enough with AI to tell anyone the difference in performance when using my 16 cores v. X number of gpu's - is it just speed, or actual "smartness?"

then there's the models. i have good storage space, so can hold a couple models, but try to keep them light. so that means i'm using models that have fewer parameters. i currently have llama3.2:latest and deepseek-r1:14b. i know neither of these are the strongest, but i would hope for decent output from them, not knowing the best ways to compare.

but i'm thinking having smaller models isn't helping the times when fabric ignores the patterns. and it seems like there are some patterns it just won't understand at this point. for example, when i pull a yt transcript, and pit that against extract_wisdom, then i get nothing more than a normal ai response giving me a very general overview. i've tried it with shorter and longer videos (all going over some kind of coherent content), and it never tries to output the ideas, insights, quotes, references, recommendations, etc. it gives me a brief summary, and that's as far as it ever goes. so maybe the pattern is too long and complex, but just for my setup? i would certainly like to, in the near future, start setting up a machine with sufficient gpu's and larger models to start handling these tasks for me, so i'm not stressing this laptop past what it really wants to do.

curious if this is lining up with everyone's experiences. am i mostly hitting the limits of my hardware combined with smaller models, or is there something else i can do to more consistently get the expected results from patterns? i have noticed that i can poke the ai in the desired direction a bit - i.e., if i'm using improve_prompt, it has a greater chance to ignore me and just do ai things if i don't start off my input with: "improve the following prompt: xxx".

[ksylvan]

Hi @mainlyetcetera

Let me see if I can reproduce what you're talking about with llama3.2:latest and deepsek-r1:14b versus claude-3-5-sonnet-latest

I'm using the same prompt with different models:

yt -t 'https://youtu.be/AMdG7IjgSPM?si=JliEosWXrbhX8vRa' | youtube_summary -m [MODEL]

llama3.2:latest

yt -t 'https://youtu.be/AMdG7IjgSPM?si=JliEosWXrbhX8vRa' | youtube_summary -m llama3.2:latest
This is a video tutorial on using the UV tool for Python package management. The tutorial covers how to use UV as an alternative to traditional tools like pip and virtual environments, and demonstrates its features such as replacing multiple tools with a single interface, managing different Python versions, building and uploading own packages to PyPI, and more.

The tutorial is structured into several sections:

1. Introduction: The creator introduces themselves and explains why they're using UV instead of traditional tools.
2. Installing UV: The creator shows how to install UV on their system.
3. Using UV for package management: The creator demonstrates how to use UV to manage Python packages, including installing, updating, and removing packages.
4. Managing different Python versions: The creator explains how UV can be used to manage multiple Python versions.
5. Building and uploading own packages: The creator shows how to build and upload their own Python packages using UV.
6. Advanced features: The creator mentions some advanced features of UV, such as building optimized Docker containers.

The tutorial concludes with a summary of the main points covered and an invitation for viewers to ask questions in the comment section below. The creator also provides links to Patreon and YouTube, where viewers can support the channel and receive future tutorials.

Some key takeaways from this tutorial include:

* UV is a powerful tool for managing Python packages that replaces multiple traditional tools with a single interface.
* UV can be used to manage different Python versions and build optimized Docker containers.
* UV makes it easy to install, update, and remove packages, as well as build and upload own packages to PyPI.

Overall, this tutorial provides a comprehensive introduction to using UV for Python package management and demonstrates its features and capabilities.

deepseek-r1:14b

yt -t 'https://youtu.be/AMdG7IjgSPM?si=JliEosWXrbhX8vRa' | youtube_summary -m deepseek-r1:14b
<think>
Alright, I just watched this video about using UV for Python package management. Hmm, it seems like UV is a tool that replaces pip and virtual environments. Let me try to understand what was covered.

So, the creator talked about installing packages with UV. Instead of using pip install, you use uv add. That makes sense; it's just a different command but probably does similar things under the hood. They mentioned that UV is faster because it uses an index like pip.index but optimized. I'm not exactly sure how that works, though.

Then there was something about virtual environments. Normally, you'd create a venv and activate it before installing packages. But with UV, you just add the package, and it handles everything in one place. That does sound convenient because managing multiple virtual environments can get messy.

They showed how to list installed packages using uv list. Similar to pip freeze but maybe more integrated since UV manages both the environment and packages together. I wonder if it's easier to switch between versions or manage dependencies this way.

Updating packages is another feature. Instead of pip install --upgrade, you use uv update. That could be useful because sometimes remembering all the flags for pip can be tricky. Plus, updating everything at once might save time.

I also noticed they talked about switching Python versions with uv python. I'm not sure how that works exactly—does it manage different installations or just change the environment variable? And using uv which to show where Python is pointing makes sense if you have multiple versions installed.

Uninstalling packages is straightforward too, with uv remove. It's nice because sometimes you forget whether a package was installed globally or in a virtualenv, but UV probably keeps track of it all.

They mentioned that UV handles everything in one place, which reduces the number of commands and complexity. That sounds appealing for someone who wants simplicity. But I'm curious about how it compares to other tools like pipx or poetry.

The creator also talked about using uv tool install to manage tools like black or flake8. Instead of installing them globally or in a venv, UV keeps them separate. That could prevent conflicts between project dependencies and dev tools.

I'm thinking about trying this out myself. How do I get started with UV? It seems like it's not as widely known as pip, so maybe the setup process is different. Are there any potential issues I should be aware of?

Also, they mentioned using uv to build and upload packages to Pypi. That could streamline the deployment process, but I'm not sure how that works compared to twine or other tools.

Overall, UV seems like a comprehensive tool that simplifies many aspects of Python package management. It might take some time to get used to the commands instead of pip, but if it makes my workflow more efficient, it's worth exploring.
</think>

UV is a modern tool designed to simplify Python package management by integrating several functionalities into a single interface, potentially streamlining your workflow compared to traditional tools like pip and virtual environments. Here's a concise summary of how UV works based on the video:

1. **Installation**: Install packages using `uv add <package>`, which handles dependencies more efficiently than `pip install`.

2. **Virtual Environments**: Manages environments seamlessly, eliminating the need for separate creation and activation steps.

3. **Listing Packages**: Use `uv list` to view installed packages, akin to `pip freeze`.

4. **Updating Packages**: Update with `uv update`, which can be more efficient than multiple pip commands.

5. **Python Version Management**: Switch versions via `uv python <version>` and check the current Python path with `uv which`.

6. **Uninstalling**: Remove packages using `uv remove <package>`.

7. **Tool Management**: Install development tools like black or flake8 with `uv tool install`, keeping them separate from project dependencies.

8. **Building & Uploading**: Streamlines package deployment to PyPI using UV commands instead of external tools.

To get started, you can install UV using pip:

pip install uv

UV aims to reduce complexity by consolidating tasks into a unified interface, making it a potential time-saver for developers.

claude-3-5-sonnet-latest

$ yt -t 'https://youtu.be/AMdG7IjgSPM?si=JliEosWXrbhX8vRa' | youtube_summary -m claude-3-5-sonnet-latest
# UV Package Manager for Python - Tutorial Summary

## Overview
This tutorial introduces UV, a modern Python package manager that aims to replace multiple tools (pip, venv, pip-tools, pipx) with a single, faster solution written in Rust. Created by Astral, UV offers a streamlined approach to Python package management.

## Key Features

[00:00:07] **Main Purpose**: UV is a new package manager for Python that combines multiple tools:
- Package installation (replaces pip)
- Virtual environment management (replaces venv)
- Lock file generation (replaces pip-tools)
- Tool installation (replaces pipx)

## Installation

[00:01:02] Multiple installation methods available:
- Homebrew (Mac)
- Standalone installer (curl command for Mac/Linux)
- PowerShell command (Windows)

## Traditional vs UV Workflow Comparison

### Traditional Workflow (pip/venv):
[00:02:14] Multiple steps required:
1. Create directory
2. Create virtual environment
3. Activate virtual environment
4. Install packages with pip
5. Create requirements.txt

### UV Workflow:
[00:05:29] Simplified process:
1. Initialize project with `uv init`
2. Add packages with `uv add`
3. Run code with `uv run`

## Project Structure

[00:07:00] UV creates a complete project structure:
- Git repository and .gitignore
- Python version file
- README.md
- main.py
- pyproject.toml

## Package Management Features

[00:09:10] **Key Capabilities**:
- Automatic virtual environment management
- Dependency tracking in pyproject.toml
- Lock file generation
- Smart global caching system

## Advanced Features

[00:20:30] **Tool Management**:
- Install system-wide tools with `uv tool install`
- Temporary tool usage with `uv tool run` or `uvx`
- Tool upgrades and management

[00:24:54] **Additional Features**:
- Python version management
- Package building and publishing
- Docker container optimization

## Advantages

[00:15:53] **Benefits**:
- Faster installation and management
- Space-efficient through global caching
- Simplified workflow
- Better dependency management
- Backwards compatibility with pip commands

## Conclusion

[00:25:48] UV offers a modern, efficient approach to Python package management, simplifying workflows while providing better performance and dependency management. It's particularly beneficial for beginners while offering advanced features for experienced developers.

As you can see, Claude does the best job, which is not surprising. The other two models are bring run locally via Ollama, and they have much more limited capabilities (and much smaller context windows).

[ksylvan]

I'm closing this issue. Some models are better than others at faithfully following instructions.