guro-py 0.1.0

Guro

Guro is a prompt & skill engineering library designed for AI agents and assistants with task-specific behavior. From academic writing to financial analysis, technical support, SEO, and beyond — Guro provides precision-crafted prompt templates ready to drop into your LLM workflows.

🚀 Overview

Guro is a curated library of 252 specialized system prompts structured for compatibility with OpenAI, Anthropic, Cohere, and other LLM providers. It’s ideal for:

• 🔬 Research Assistants & Academic Writers
• 🧾 Budget Analysis & Financial Planning
• 🧠 Reasoning Agents
• 🎨 ASCII Artist & Visual Designers
• 🧩 General AI Agents with Task-Scoped Roles

📂 Project Structure

Guro/
└── guro/
    ├── __init__.py
    ├── instructions/
    │   ├── __init__.py
    │   ├── text.py
    │   ├── image.py
    │   └── audio.py
    ├── README.md
    ├── LICENSE
    ├── requirements.txt
    ├── data/
    │   └── Prompts.db
    ├── ipynb/
    │   └── ...
    ├── prompts/
    │   ├── AcademicWriter.md
    │   ├── BudgetAnalyst.md
    │   ├── DataScientist.md
    │   ├── ExpertProgrammer.md
    │   └── ...
    └── resources/
        └── Images/
            └── Github/
                └── guro_project.png

🐍 Instruction Library

The Guro instruction catalog is organized as an instructions package rather than a single monolithic instructions.py module. The package contains 252 prompt constants grouped by modality while preserving the original uppercase snake-case names and Markdown instruction text.

guro/instructions/
├── __init__.py
├── text.py
├── image.py
└── audio.py

The package-level guro.instructions namespace acts as the compatibility layer and exposes the complete instruction catalog. Existing code that imports instructions through the package can therefore continue to use the same public access pattern:

from guro import instructions

Individual modality modules may also be imported directly when an application only needs a specific class of instructions:

from guro.instructions import text
from guro.instructions import image
from guro.instructions import audio

Or individual prompt constants can be imported from their owning module:

from guro.instructions.text import ACADEMIC_WRITER
from guro.instructions.image import IMAGE_ANALYZER
from guro.instructions.audio import VERBATIM_TRANSCRIBER

Instruction Categories

The instruction modules are derived from the prompt categories maintained in the Guro prompt catalog.

This separation keeps text-oriented system instructions independent from image and audio API instructions while preserving one unified public catalog through guro.instructions.

Public API

Each instruction module declares its prompt constants explicitly and exposes the same helper API for discovery, iteration, and dynamic lookup. The package-level compatibility layer provides that API across all three modules.

Each submodule also provides its own __all__, names(), values(), items(), and get() members for modality-specific discovery.

🎯 Direct Instruction Access

Use package-level direct attribute access when the required instruction is known while writing the application:

from guro import instructions

system_instruction = instructions.ACADEMIC_WRITER

print( system_instruction )

The compatibility namespace resolves constants from all three modality modules:

from guro import instructions

text_instruction = instructions.DATA_SCIENTIST
image_instruction = instructions.IMAGE_ANALYZER
audio_instruction = instructions.VERBATIM_TRANSCRIBER

🧭 Modality-Specific Access

Import a submodule when an application should work only with one instruction modality:

from guro.instructions import text

system_instruction = text.EXPERT_PROGRAMMER

print( system_instruction )

Image instructions are available from image.py:

from guro.instructions import image

system_instruction = image.IMAGE_ANALYZER

print( system_instruction )

Audio instructions are available from audio.py:

from guro.instructions import audio

system_instruction = audio.VERBATIM_TRANSCRIBER

print( system_instruction )

🔎 Dynamic Instruction Lookup

Use the package-level get() function when an instruction name comes from configuration, user selection, a database, or another runtime source:

from guro import instructions

instruction_name = 'DATA_SCIENTIST'
system_instruction = instructions.get( instruction_name )

print( system_instruction )

An undefined instruction raises KeyError:

from guro import instructions

try:
    system_instruction = instructions.get( 'UNDEFINED_INSTRUCTION' )
except KeyError as ex:
    print( ex )

The same lookup pattern is available on individual modality modules:

from guro.instructions import image

system_instruction = image.get( 'IMAGE_ANALYZER' )

📋 Iterate Over Instruction Names

The package-level names() function returns the complete exported instruction catalog:

from guro import instructions

for instruction_name in instructions.names( ):
    print( instruction_name )

For a modality-specific catalog, call names() on the corresponding module:

from guro.instructions import audio

for instruction_name in audio.names( ):
    print( instruction_name )

This is useful for populating dropdown lists, command-line menus, configuration tools, and user-selectable interfaces.

🔁 Iterate Over Instruction Values

The values() function returns each exported instruction text:

from guro import instructions

for instruction_text in instructions.values( ):
    print( instruction_text )

The same operation can be scoped to one modality:

from guro.instructions import image

for instruction_text in image.values( ):
    print( instruction_text )

🧩 Iterate Over Names and Text

Use items() when both the instruction name and its Markdown text are required:

from guro import instructions

for instruction_name, instruction_text in instructions.items( ):
    print( f'Instruction: {instruction_name}' )
    print( instruction_text )
    print( )

🖥️ Build a User-Selectable Catalog

Instruction names can be displayed to a user and resolved dynamically:

from guro import instructions

available_instructions = instructions.names( )

for index, instruction_name in enumerate( available_instructions, start=1 ):
    print( f'{index}. {instruction_name}' )

selected_index = 1
selected_name = available_instructions[ selected_index - 1 ]
selected_instruction = instructions.get( selected_name )

print( selected_instruction )

A UI can also expose separate modality selectors:

from guro.instructions import audio, image, text

text_options = text.names( )
image_options = image.names( )
audio_options = audio.names( )

🗂️ Filter Instructions by Name

Because instruction members use uppercase snake case, they can still be filtered predictably:

from guro.instructions import text

data_instruction_names = tuple(
    name for name in text.names( )
    if name.startswith( 'DATA_' )
)

for instruction_name in data_instruction_names:
    print( instruction_name )

📦 Create a Dictionary Catalog

Use items() to create a standard dictionary for filtering, serialization, testing, or UI binding:

from guro import instructions

instruction_catalog = dict( instructions.items( ) )

system_instruction = instruction_catalog[ 'EXPERT_PROGRAMMER' ]

print( system_instruction )

A modality-specific catalog can be created the same way:

from guro.instructions import image

image_catalog = dict( image.items( ) )

🤖 Pass an Instruction to an LLM Client

Text instruction values remain standard Python strings and can be passed directly as system instructions or system messages:

from guro.instructions import text

system_instruction = text.EXPERT_PROGRAMMER

messages = [
    {
        'role': 'system',
        'content': system_instruction,
    },
    {
        'role': 'user',
        'content': 'Review this Python function for correctness.',
    },
]

Image and audio instruction strings can likewise be supplied to API workflows that accept instructional text:

from guro.instructions import audio, image

image_instruction = image.IMAGE_ANALYZER
audio_instruction = audio.VERBATIM_TRANSCRIBER

🧠 Tooling Support

All prompt constants remain concrete Python symbols, preserving IDE completion, static-analysis support, type-checker visibility, and documentation-generation compatibility.

Each modality module defines an explicit __all__ tuple for its supported public symbols. The package-level instructions.__all__ combines those catalogs into the complete 252-instruction public API, while names(), values(), items(), and get() provide stable discovery and runtime lookup interfaces.

The modular design provides three advantages:

• Separation of concerns — text, image, and audio workflows no longer share one very large source module.
• Selective imports — applications can load only the modality-specific catalog they need.
• Backward compatibility — existing from guro import instructions usage continues to expose the unified catalog.

🌟 Automation Analyst

📊 Apportionment Processor

📝 Academic Writer

📊 Adaptive Analyst

🎨 ASCII Artist

🧩 Agenda Maker

🎯 Artsy Fartsy

😀 Author Emulator

🏛️ Appropriations Analyst

🧠 Budget Analyst

🧙 Budget Gandolf

👨‍🚀 Budget Buddy

🕵️ Business Analyst

🗂️ Business Planner

🔍 Business Researcher

📝 Book Summarizer

🧠 Brain Stormer

⚙️ Complex Problem Analyst

🧠 Chain Of Density

🧩 Checklist Creator

🧐 Code Reviewer

🌟 Cognitive Profiler

🔍 Company Researcher

🧠 Course Creator

🧐 Critical Thinker

📊 Data Analyst

🌟 Data Cleaner

🔎 Data Farmer

🎯 Data Plumber

🌐 Data Scientist

🌟 Data Visualizer

🧠 Dataset Analyzer

🧩 Decision Maker

🎯 Dependency Indentifier

🌐 Document Interrogator

🧾 Document Summarizer

🎯 Dashboard Analyst

🌟 Excel Ninja

📝 Educational Writer

🤖 Email Assistant

🧩 Entertainment Advisor

📝 Essay Writer

🧩 Evaluation Expert

🤖 Executive Assistant

💻 Expert Programmer

🎯 Excel Analyst

📊 Exploratory Data Analyzer

🏗️ Feature Department

🗂️ Financial Planner

🗂️ Financial Advisor

🗂️ Financial Analyst

🏗️ Form Builder

🌍 Geographic Guesser

🏗️ How-To Builder

🎤 Interview Coach

📊 Investment Analyst

🌟 Innovation Analyst

🧩 Jack Of All Trades

⚡ Keyword Generator

⚙️ Legal Analyst

🌐 Management Consultant

📈 Market Forecaster

🗂️ Market Planner

🔍 Market Researcher

🧙 Mathy Magician

🎯 Media Profile Designer

⚙️ Meeting Optimizer

🧾 Meeting Summarizer

🎓 Multi Professor

🧩 Outlook Analyst

🎯 PBI Expert

🧙 PBI Analyst

🌐 PDF Parser

🤖 Personnal Assistant

🧩 Power Pointer

🧠 Problem Solver

🛠️ Process Engineer

🧙 Power Query Analyst

🎯 Project Architech

🗂️ Project Planner

🌐 Prompt Enhancer

📋 Prompt Evaluator

🧙 Procurement Analyst

⚡ Prompt Generator

🛠️ Prompt Refiner

🧩 Proofreading Specialist

🤖 Python Analyst

📝 Random Writer

🧠 Research Analyst

📊 Reasoning Analyst

🧩 Research Expert

🌐 Results Creator

🏗️ Resume Builder

📝 Resume Writer

🧩 Revenue Projector

⚡ Root-Cause Analyzer

🧩 Red Team Analyst

⚡ Sentiment Analyst

⚙️ Search Optimizer

📊 SQL Analyst

🧐 Strategic Thinker

🧠 Structured Problem Solver

🗂️ Sustainability Planner

🧠 Speech Writer

🧙 Statistics Analyst

🗂️ Task Planner

🤖 Teaching Assistant

📊 Tech-Support Analyst

🎯 Training Content Designer

🎯 Training Plan Designer

🗂️ Training Planner

⚡ Training Wheels

🎯 Wealth Analyst

🎯 Web Designer

⚙️ Web Search Optimizer

✏️ Writing Editor

🧙 What-If Analyst

✍️ Youtube Scribe

🧾 Youtube Summarizer

🧾 Document Summarizer

📋 Prompt Evaluator

📝 License

Guro is published under the MIT General Public License v3.