The Ultimate Resource Guide for Prompt Engineering & Public APIs

The Shift Toward Prompt Engineering and Composable APIs

We are in the midst of a massive shift in how software is built. Just a few years ago, building an intelligent application required training your own machine learning models, collecting massive datasets, and managing complex cloud infrastructure. It was expensive, slow, and reserved for teams with specialized data science knowledge.

Today, the landscape is entirely different. Building intelligent products has become an exercise in composition and communication. Rather than building models from scratch, developers are composing applications using free public APIs and orchestrating their logic through advanced prompt engineering. The combination of these two elements—access to real-world data via APIs and the reasoning capabilities of Large Language Models (LLMs)—has democratized software development.

Think of a public API as the sensory organs of your application. It allows your software to "see" the weather, "hear" financial market updates, or "feel" the sentiment of a Twitter feed. Alone, this data is just raw information. But when you feed this data into an LLM using expert prompt engineering, the AI acts as the brain. It interprets the data, draws conclusions, and generates meaningful output.

However, getting an LLM to reliably process this data isn't as simple as typing a question into a chat box. It requires a deep understanding of how language models process instructions, manage context, and format outputs. This is where prompt engineering comes in. It is the discipline of designing the input text to guide the model toward the exact output you need, minimizing hallucinations and maximizing consistency.

In this guide, we are going to explore the most powerful, open-source resources available in 2026 for mastering prompt engineering and finding the best public APIs. Whether you are a beginner looking to build your first AI wrapper or a seasoned engineer optimizing a production-grade system, these repositories will provide the foundation you need.

The Top Open-Source Resources

1. Public APIs (public-apis/public-apis)

Every great application needs data, and finding reliable, free data sources can be a daunting task. The public-apis/public-apis repository is a legendary directory in the developer community. It is a massive, community-maintained list of free APIs available for software development, categorized by topic.

When you are prototyping a new AI application, you rarely want to pay for premium data feeds right out of the gate. This repository provides access to APIs covering everything from Anime and Cryptocurrencies to Health, Machine Learning, and Space exploration.

For example, imagine you are building an AI travel assistant. You need data on weather, flight delays, and local currency exchange rates. Instead of scraping websites (which is fragile and often against terms of service), you can navigate to this repository and find the exact JSON endpoints you need.

// Example: Fetching data from a public API to feed to an LLM
async function getWeatherData(city) {
  const response = await fetch(`https://api.open-meteo.com/v1/forecast?latitude=52.52&longitude=13.41&current_weather=true`);
  const data = await response.json();
  
  // You can now pass 'data' directly into your LLM prompt
  return `Current temperature is ${data.current_weather.temperature}°C`;
}

The beauty of this directory is that it clearly indicates whether an API requires an authentication key, supports HTTPS, and allows Cross-Origin Resource Sharing (CORS). This makes it incredibly easy to filter for APIs that can be called directly from your frontend code without needing a dedicated backend proxy.

2. Prompt Master (nidhinjs/prompt-master)

Once you have your data from a public API, you need to tell the LLM what to do with it. This is where Prompt Master comes in. Prompt Master is an advanced framework and collection of resources dedicated entirely to the science of prompt engineering.

Beginners often make the mistake of writing prompts like they are talking to a human: "Hey, can you look at this weather data and tell me if I need a jacket?" While this works for casual chat, it is disastrous for production software. The LLM might respond with a joke, a long-winded essay, or a completely unpredictable format.

Prompt Master teaches you how to structure your prompts using frameworks like Few-Shot Prompting, Chain-of-Thought, and ReAct (Reasoning and Acting). It provides templates for enforcing strict JSON outputs, handling edge cases, and guiding the model's persona.

For instance, if you are building an application that needs to extract specific entities from an API response, Prompt Master will show you how to write a system prompt that explicitly defines the output schema, preventing the LLM from adding conversational filler like "Here is the JSON you requested."

// Example: A structured prompt enforcing JSON output
const prompt = `
You are a data extraction assistant. Your task is to analyze the following text and extract the names of people and their occupations.

RULES:
1. You must respond ONLY with valid JSON.
2. Do not include any conversational text or markdown formatting.
3. Use the following schema:
{
  "people": [
    { "name": "string", "occupation": "string" }
  ]
}

TEXT TO ANALYZE:
${inputText}
`;

3. Awesome NotebookLM Prompts (serenakeyitan/awesome-notebookLM-prompts)

Google's NotebookLM has revolutionized how we interact with our own documents. Unlike general-purpose chatbots that rely on their training data (and often hallucinate facts), NotebookLM is grounded entirely in the sources you provide. It is essentially Retrieval-Augmented Generation (RAG) simplified for the end-user.

However, getting the most out of NotebookLM requires a different style of prompting than standard ChatGPT or Claude. The Awesome NotebookLM Prompts repository is a curated collection of techniques designed specifically for unlocking the power of this tool.

This repository is invaluable for students, researchers, and professionals who need to synthesize large amounts of information. It provides prompts for generating study guides, creating contrasting viewpoints between multiple uploaded documents, and extracting timelines from historical texts.

A common use case is analyzing competitive intelligence. You can upload several competitor whitepapers to NotebookLM and use a prompt from this repository to ask the model to generate a feature matrix comparing the products, highlighting areas where one product explicitly claims superiority over another based only on the provided texts.

4. Understand Anything (Egonex-AI/Understand-Anything)

One of the most profound use cases for LLMs is education and learning. The Understand Anything repository focuses on using prompt engineering to break down complex topics into digestible, understandable components.

This repository is a masterclass in utilizing the Feynman Technique via AI. It provides structured prompts that instruct the LLM to explain concepts at various levels of complexity—from a 5-year-old to a PhD student. It goes beyond simple explanations by incorporating analogies, practical examples, and Socratic questioning.

When you are trying to learn a new programming concept, such as recursion or memory management, using the prompts from "Understand Anything" can drastically reduce your learning time. The prompts are designed to identify your knowledge gaps and dynamically adjust the explanation based on your previous answers.

Developers can also integrate these prompts into their own applications. If you are building an educational platform, you can use these prompt structures as the backbone of your AI tutoring system, ensuring that the AI provides pedagogical value rather than just handing the user the answers.

5. Graphify (Graphify-Labs/graphify)

As we move toward more advanced AI systems, simply generating text is no longer enough. We need AI that understands the relationships between concepts. This is the domain of Knowledge Graphs. The Graphify repository provides tools for building knowledge graphs from unstructured text.

A knowledge graph maps out entities (nodes) and their relationships (edges). Instead of a flat document, you get a web of interconnected facts. Graphify uses LLMs to read unstructured text—such as news articles, legal documents, or codebase documentation—and automatically extract these nodes and edges.

Why is this important for prompt engineering? Because injecting a knowledge graph into your prompt provides the LLM with a structural understanding of the domain. It reduces hallucinations because the model's reasoning is constrained by the factual relationships defined in the graph.

For example, if you are building an AI agent to analyze medical literature, feeding it a knowledge graph of symptoms, diseases, and treatments ensures it understands the established connections before generating a response. Graphify provides the open-source pipeline to turn your raw text into these powerful structured graphs.

Real-World Usage at PPT Maker

At PPT Maker, we don't just write about these concepts; we use them every day to power our tools. The principles of composable public APIs and rigorous prompt engineering are the foundation of our student and professional suite.

Take our Cover Letter AI as an example. Generating a generic cover letter is easy, but generating a highly personalized, compelling cover letter requires strict prompt constraints. We use advanced techniques from resources like Prompt Master to enforce the structure of the letter. Our prompts instruct the AI to analyze the user's resume, extract their most relevant achievements, and weave them into a narrative that aligns specifically with the job description. We enforce tone guidelines—professional yet passionate—and strictly forbid the AI from inventing experiences the user doesn't have.

Similarly, our Application Vault relies heavily on structured data extraction. When a user uploads various application materials, we use prompt engineering to parse and categorize the information into a structured format. This ensures that when the user needs to quickly recall a specific project detail for an interview, the data is perfectly organized and easily retrievable.

Even our ATS Resume Checker is powered by these methodologies. The checker doesn't just look for keyword matches; it uses carefully crafted prompts to simulate an Applicant Tracking System's parsing logic. By providing the LLM with specific instructions on how to evaluate formatting, keyword density, and action verbs, we generate highly accurate, actionable feedback that helps users get their resumes past the automated filters.

Building these tools required hundreds of hours of iterating on prompts, managing context windows, and parsing API responses. The open-source resources listed in this article were instrumental in teaching us how to handle these challenges at scale.

Start Building Today

The barrier to entry for building intelligent software has never been lower. Armed with the public APIs directory for data and the prompt engineering frameworks from Prompt Master and NotebookLM, you have everything you need to start composing powerful applications.

But you don't have to build everything from scratch to take advantage of these technologies. If you are looking to optimize your job search or streamline your academic workflow, we have already done the heavy lifting for you.

Experience the power of advanced prompt engineering firsthand. Try our Cover Letter AI to generate a tailored application in seconds, or use the Application Vault to manage your entire job search process with AI precision. The future of software is composable, and the tools are already waiting for you.