DEV Community: oussama errafif

How to Build a Resilient AI-Powered Research Agent with LangChain, Gemini, and DuckDuckGo

oussama errafif — Mon, 21 Jul 2025 16:49:39 +0000

🧠 Build a Resilient AI Research Agent with Gemini + LangChain (No APIs? No Problem.)

In this guide, you'll build a research super-agent that:

✅ Performs deep research on any topic
✅ Handles web/API failures gracefully
✅ Enhances its output with verifiable claims
✅ Generates a full professional report
✅ Uses Google Gemini, DuckDuckGo, Wikipedia, and optionally SerpAPI

🤔 Why This Matters

Most AI research agents work like this:

Take a topic
Query an LLM
Dump the result

What’s wrong with that?

They fail when web search APIs are down
They hallucinate facts
They don’t verify anything
They can’t format output beyond a paragraph dump

This agent fixes all of that by combining multiple tools, smart rate-limiting, and multi-phase verification.

Let’s build it, step by step.

⚙️ Step 1: Install Required Tools

We need LangChain to connect LLMs and tools, Gemini for powerful reasoning, and dotenv for environment configs.

pip install langchain-google-genai python-dotenv requests

🧾 Step 2: Set Environment Variables

Create a .env file in your project directory with your API keys:

GOOGLE_API_KEY=your_google_api_key_here
SERPAPI_KEY=your_serpapi_key_here  # optional

❗ You can still run the system without SerpAPI. DuckDuckGo and Wikipedia are enough for many topics.

🔍 Step 3: Create a Multi-Source Search System

We use DuckDuckGoSearchRun via LangChain for fast, no-auth search. If that fails, we fallback to Wikipedia. If SerpAPI is present, we use that too.

import time, os, requests
from langchain_community.tools import DuckDuckGoSearchRun
from dotenv import load_dotenv

load_dotenv()

class ImprovedSearchSystem:
    def __init__(self):
        self.search = DuckDuckGoSearchRun()
        self.search_delay = 3.0
        self.last_search_time = 0

    def safe_web_search(self, query):
        now = time.time()
        if now - self.last_search_time < self.search_delay:
            time.sleep(self.search_delay - (now - self.last_search_time))
        self.last_search_time = time.time()

        for name, method in [
            ("DuckDuckGo", self._try_duckduckgo),
            ("Wikipedia", self._try_wikipedia),
            ("SerpAPI", self._try_serpapi if os.getenv("SERPAPI_KEY") else None)
        ]:
            if method is None: continue
            try:
                result = method(query)
                if result and len(result.strip()) > 50:
                    return f"[{name}] {result}"
            except Exception:
                continue
        return "Search unavailable or no results."

    def _try_duckduckgo(self, query):
        return self.search.invoke(query)

    def _try_wikipedia(self, query):
        q = "_".join(query.split()[:3])
        r = requests.get(f"https://en.wikipedia.org/api/rest_v1/page/summary/{q}")
        if r.status_code == 200:
            return r.json().get("extract", "")
        return ""

    def _try_serpapi(self, query):
        params = {"q": query, "api_key": os.getenv("SERPAPI_KEY")}
        r = requests.get("https://serpapi.com/search", params=params)
        results = r.json().get("organic_results", [])
        return "\n".join(f"{r['title']}: {r.get('snippet', '')}" for r in results[:2])

✅ What this does:

Avoids hitting the same search source every time
Skips broken sources
Doesn’t block if internet is slow

🧠 Step 4: Add Google Gemini via LangChain

We'll use Gemini to do the heavy lifting: writing, verifying, summarizing, polishing.

from langchain_google_genai import ChatGoogleGenerativeAI

class RobustResearchOrchestrator:
    def __init__(self):
        self.llm = ChatGoogleGenerativeAI(
            model="gemini-1.5-flash-latest",
            temperature=0.7,
            google_api_key=os.getenv("GOOGLE_API_KEY")
        )
        self.search = ImprovedSearchSystem()
        self.llm_delay = 2.0
        self.last_llm_time = 0

    def _rate_limit_llm(self):
        now = time.time()
        if now - self.last_llm_time < self.llm_delay:
            time.sleep(self.llm_delay - (now - self.last_llm_time))
        self.last_llm_time = time.time()

📚 Step 5: Research with Web Context

    def research_with_llm_knowledge(self, topic, web_context=""):
        self._rate_limit_llm()
        prompt = f"""
Research the following topic thoroughly:

Topic: {topic}
{f"Web context: {web_context}" if web_context else ""}

Include:
1. Definitions
2. 2024-2025 breakthroughs
3. Key players
4. Challenges
5. Future outlook
6. Technical details
"""
        return self.llm.invoke(prompt).content

✅ Why this matters:
You’re not just asking the LLM for trivia—you’re giving it timely web data as context.

🔎 Step 6: Enhance with Web-Verified Claims

    def enhance_with_verification(self, content, topic):
        self._rate_limit_llm()
        extract_prompt = f"""
Extract 2 verifiable claims from this research on {topic}:

{content[:2000]}
"""
        claims = self.llm.invoke(extract_prompt).content.splitlines()
        verified = []

        for claim in claims[:2]:
            search_result = self.search.safe_web_search(claim)
            if search_result and len(search_result) > 100:
                verified.append(f"{claim}\nVerified: {search_result}")

        if not verified:
            return content

        enhance_prompt = f"""
Update this research with the following verified information:

Original:
{content}

Verified Data:
{chr(10).join(verified)}

Mark updated lines with [VERIFIED].
"""
        return self.llm.invoke(enhance_prompt).content

✅ Why this matters:
You extract and fact-check your own LLM output. Self-auditing makes your system more trustworthy.

📄 Step 7: Format as a Full Report

    def create_report(self, enhanced, topic):
        self._rate_limit_llm()
        report_prompt = f"""
Convert the following into a full technical report on '{topic}' with:

- Executive Summary
- Introduction
- Breakthroughs
- Key Players
- Technical Details
- Challenges
- Future Outlook
- Conclusion

Content:
{enhanced}
"""
        return self.llm.invoke(report_prompt).content

💅 Step 8: Polish for Professional Quality

    def polish_report(self, report):
        self._rate_limit_llm()
        return self.llm.invoke(f"Polish this technical report:\n\n{report}").content

🧪 Step 9: Run the Entire Pipeline

    def run_pipeline(self, topic):
        context = self.search.safe_web_search(f"{topic} 2024 update")
        content = self.research_with_llm_knowledge(topic, context)
        enhanced = self.enhance_with_verification(content, topic)
        report = self.create_report(enhanced, topic)
        final = self.polish_report(report)
        return final

🧯 Step 10: Command Line Runner

def run_robust_research(topic):
    orchestrator = RobustResearchOrchestrator()
    return orchestrator.run_pipeline(topic)

if __name__ == "__main__":
    topic = input("Enter a research topic: ").strip()
    print(run_robust_research(topic))

🧠 Example: Output for "AI Hardware in 2025"

Executive Summary:
AI hardware has rapidly evolved...

Breakthroughs:
- NVIDIA’s Blackwell GPU architecture...
- Intel’s neuromorphic Loihi chip...

Key Players:
- NVIDIA, Intel, Graphcore, Cerebras...

Challenges:
- Energy efficiency, heat dissipation...

[VERIFIED] Blackwell GPUs announced March 2025 with 4x efficiency...

🔚 Final Thoughts

This agent is:

✅ Self-healing (fallbacks and retries)
✅ Fact-aware (claim verification)
✅ Pro-quality (full report structure)
✅ Flexible (extendable to PDF, Slack, APIs)

You now have a bulletproof research pipeline that works even if APIs don’t.

Metaprogramming in Python: A Complete Guide

oussama errafif — Fri, 04 Oct 2024 09:00:56 +0000

Metaprogramming in Python: A Complete Guide

Metaprogramming is a powerful programming concept that involves writing code that can manipulate other code. In Python, metaprogramming enables developers to dynamically alter classes, functions, and other constructs at runtime. This allows for highly flexible, dynamic, and reusable code, making it a popular technique in advanced Python development.

Key Concepts of Metaprogramming

Code that Modifies Code:
In metaprogramming, you write code that can alter or generate code dynamically. This makes it possible to automate repetitive tasks, optimize performance, and adapt functionality without needing to modify the original code base manually.
Dynamic Nature of Python:
Python is a dynamic language, meaning its objects can be modified at runtime. You can add or change the attributes and methods of classes and functions on the fly, enabling a great deal of flexibility in program behavior.

Key Techniques in Metaprogramming

Decorators: Decorators are one of the most common tools in metaprogramming. A decorator is a higher-order function that takes another function (or method) and extends or modifies its behavior without changing its original code.

Example:

   def my_decorator(func):
       def wrapper(*args, **kwargs):
           print("Before calling the function")
           result = func(*args, **kwargs)
           print("After calling the function")
           return result
       return wrapper

   @my_decorator
   def say_hello(name):
       print(f"Hello, {name}")

   say_hello("Alice")

Output:

   Before calling the function
   Hello, Alice
   After calling the function

In this example, the my_decorator function modifies the behavior of say_hello by adding print statements before and after the original function execution.

Metaclasses: Metaclasses are another powerful feature of metaprogramming in Python. A metaclass is the "class of a class," meaning it defines how classes themselves are constructed. By customizing metaclasses, you can dynamically alter the behavior of class creation, allowing you to change methods, attributes, or add new functionality to classes at the moment they are defined.

Example:

   class Meta(type):
       def __new__(cls, name, bases, dct):
           print(f"Creating class {name}")
           return super().__new__(cls, name, bases, dct)

   class MyClass(metaclass=Meta):
       pass

Output:

   Creating class MyClass

In this case, the Meta metaclass is used to modify the class creation process, printing a message whenever a class is created.

__getattr__ and __setattr__: These magic methods allow for controlling the behavior of attribute access. __getattr__ is called when trying to access an attribute that doesn’t exist, while __setattr__ is invoked whenever an attribute is set. This is a form of metaprogramming because it allows you to define custom behavior for attribute handling dynamically.

Example:

   class DynamicAttributes:
       def __getattr__(self, name):
           return f"No such attribute: {name}"

   obj = DynamicAttributes()
   print(obj.some_attribute)  # Output: No such attribute: some_attribute

type() Function: Python’s type() function is not only used to get the type of an object, but it can also be used to create new classes dynamically. This allows you to define classes on the fly without using the traditional class keyword.

Example:

   MyClass = type("MyClass", (object,), {"attr": "value"})
   obj = MyClass()
   print(obj.attr)  # Output: value

Class Decorators: Just like function decorators, you can also use decorators to modify class behavior. A class decorator is applied to an entire class, allowing you to add methods, change attributes, or manipulate behavior in one go.

Example:

   def add_method(cls):
       cls.new_method = lambda self: "New Method"
       return cls

   @add_method
   class MyClass:
       pass

   obj = MyClass()
   print(obj.new_method())  # Output: New Method

The inspect Module: The inspect module provides functions that allow you to introspect and manipulate live objects, such as retrieving information about functions, methods, classes, and objects at runtime. This is especially useful for debugging, dynamic code generation, and extending Python’s capabilities.

Example:

   import inspect

   def example_function(x):
       return x * 2

   print(inspect.getsource(example_function))

This will print the source code of the example_function.

Advantages of Metaprogramming

Code Reduction: By automating repetitive patterns and generating code dynamically, metaprogramming can significantly reduce the amount of code you need to write and maintain.
Flexibility: Metaprogramming enables a higher level of flexibility in your programs. You can define functions, classes, or behaviors that can adapt at runtime to different contexts or conditions.
Reusability: Decorators and metaclasses allow you to extend the functionality of multiple classes or functions in a clean, reusable manner.
Dynamic Code Generation: When you need to build highly dynamic applications where the behavior of the code can change based on different inputs, metaprogramming can be an ideal tool.

When to Use Metaprogramming

When you need to extend functionality dynamically: Instead of manually writing repetitive code, metaprogramming allows you to define reusable logic that can adapt to changing needs.
For framework or library development: Metaprogramming is often used in frameworks to provide developers with simple APIs while handling the complexity behind the scenes.
When creating dynamic systems: For applications that need to change behavior at runtime (such as plugin systems, interpreters, or dynamic APIs), metaprogramming provides a flexible way to handle such dynamic requirements.

Conclusion

Metaprogramming in Python provides a set of powerful tools for writing flexible, efficient, and reusable code. By leveraging decorators, metaclasses, and other metaprogramming techniques, you can automate repetitive tasks, enhance your code's flexibility, and create dynamic, adaptive programs. However, metaprogramming should be used judiciously, as it can make code more complex and harder to debug if not carefully implemented.

Understanding and mastering these techniques will help you elevate your Python programming to a whole new level!

Python Generators: A Complete Guide

oussama errafif — Fri, 04 Oct 2024 08:58:04 +0000

Python Generators: A Complete Guide

Python generators are a powerful tool for creating iterators in an efficient and concise manner. They allow you to generate a sequence of values lazily, meaning that instead of producing all the values upfront, they generate each value on-the-fly when needed. This makes generators highly memory-efficient, especially when working with large datasets or infinite sequences.

Key Concepts of Python Generators

Lazy Evaluation:
Unlike lists that hold all values in memory, generators only produce one value at a time. This "lazy evaluation" makes them ideal for working with massive datasets where storing everything at once would be impractical.
The yield Keyword:
The core difference between generators and regular functions lies in the yield keyword. In a typical function, return sends a value back to the caller and ends the function. With yield, the function’s state is paused and can be resumed later. Each time the generator is called, it resumes execution right where it left off, yielding the next value in the sequence.

Example:

   def simple_generator():
       yield 1
       yield 2
       yield 3

   gen = simple_generator()
   print(next(gen))  # Output: 1
   print(next(gen))  # Output: 2
   print(next(gen))  # Output: 3

In this example, the simple_generator() returns a generator object, and each time you call next(), it provides the next value.

How Generators Work: A generator function returns a generator object, which is an iterator. This generator object can be iterated over using next(), or more commonly in loops like for, without loading the entire sequence into memory at once.

Example with a loop:

   def countdown(n):
       while n > 0:
           yield n
           n -= 1

   for number in countdown(5):
       print(number)

Output:

Generators vs. Iterators:
- Iterator: Any object that implements the iterator protocol, meaning it has __iter__() and __next__() methods.
- Generator: A special type of iterator created with a function that uses yield. It simplifies the creation of iterators, since Python takes care of implementing the necessary methods behind the scenes.
Memory Efficiency:
Generators are especially useful for working with streams of data or large collections where loading everything into memory isn’t feasible. Instead of creating a list with all elements at once, you can generate and process one element at a time.

Example: Generating Fibonacci numbers

   def fibonacci():
       a, b = 0, 1
       while True:
           yield a
           a, b = b, a + b

   fib = fibonacci()

   for i in range(10):
       print(next(fib))

Infinite Sequences: Generators can also be used to represent infinite sequences, something not possible with lists. For example, the Fibonacci generator in the example above can run indefinitely, producing as many Fibonacci numbers as needed without ever running out of memory.

Generator Expressions

Just like list comprehensions, Python also provides generator expressions, which allow for a more compact syntax to create generators.

Example:

gen_exp = (x * x for x in range(5))

for num in gen_exp:
    print(num)

This looks very similar to a list comprehension, but with parentheses instead of square brackets. The key difference is that a generator expression doesn’t compute all values immediately, making it more memory efficient.

Advantages of Generators

Memory Efficiency: Since generators yield one item at a time, they can handle large datasets without consuming much memory.
Better Performance: For large sequences, generators often outperform list-based solutions due to their lazy nature.
Simplified Code: With the yield keyword, Python abstracts much of the complexity involved in writing iterators manually.

When to Use Generators

Dealing with large data: When working with data that is too large to fit into memory all at once.
Processing streams: For reading or writing files line by line, processing network requests, or handling real-time data streams.
Handling infinite sequences: When you need an iterator that produces values indefinitely without running out of memory.

Conclusion

Generators provide an elegant way to work with large or potentially infinite data streams efficiently. By leveraging the yield keyword and lazy evaluation, they reduce memory usage and can make your programs more performant. When your application involves large datasets or continuous data streams, generators are a tool you can rely on to write cleaner, more efficient code.

Advanced Python Techniques: Metaclasses, Decorators, and Context Managers

oussama errafif — Sun, 25 Aug 2024 22:09:28 +0000

Python is renowned for its simplicity and readability, which makes it a great language for both beginners and experienced developers. However, beneath its easy-to-understand syntax lies a depth of advanced features that can significantly enhance your programming capabilities. In this post, we will delve into three advanced Python techniques: metaclasses, decorators, and context managers. We'll explore what they are, how they work, and how they can be used effectively in your projects.

1. Metaclasses: The Class of a Class

In Python, everything is an object, and this includes classes themselves. Metaclasses are a concept that allows you to control the creation and behavior of classes. To understand metaclasses, you need to first grasp that classes are themselves instances of metaclasses. By default, Python uses type as the metaclass for all new classes. However, you can create your own metaclasses to modify or enhance the class creation process.

Example: Custom Metaclass

class UpperCaseMeta(type):
    def __new__(cls, name, bases, dct):
        uppercase_attrs = {k.upper(): v for k, v in dct.items()}
        return super().__new__(cls, name, bases, uppercase_attrs)

class MyClass(metaclass=UpperCaseMeta):
    foo = 'bar'

print(hasattr(MyClass, 'foo'))  # False
print(hasattr(MyClass, 'FOO'))  # True

In this example, UpperCaseMeta is a metaclass that transforms all attribute names to uppercase. By using this metaclass, the foo attribute in MyClass is automatically converted to FOO.

When to Use Metaclasses

Metaclasses are a powerful tool for cases where you need to enforce specific patterns or constraints in class definitions. They can be used for:

Automatically adding methods or attributes to classes.
Enforcing naming conventions.
Validating class definitions.

2. Decorators: Enhancing Functionality

Decorators are a design pattern that allows you to modify or enhance functions or methods without changing their actual code. They are widely used in Python for adding functionality to functions or methods in a clean and readable manner.

Example: Simple Decorator

def my_decorator(func):
    def wrapper():
        print("Something is happening before the function.")
        func()
        print("Something is happening after the function.")
    return wrapper

@my_decorator
def say_hello():
    print("Hello!")

say_hello()

Output:

Something is happening before the function.
Hello!
Something is happening after the function.

In this example, my_decorator wraps the say_hello function, adding behavior before and after its execution.

When to Use Decorators

Decorators are useful for:

Logging function calls.
Measuring execution time.
Access control and authentication.
Caching results.

3. Context Managers: Managing Resources

Context managers are a mechanism for managing resources such as file handles, network connections, or locks, ensuring that they are properly acquired and released. The most common way to use a context manager is with the with statement, which ensures that resources are cleaned up after use, even if an error occurs.

Example: Custom Context Manager

class ManagedFile:
    def __init__(self, filename, mode):
        self.filename = filename
        self.mode = mode

    def __enter__(self):
        self.file = open(self.filename, self.mode)
        return self.file

    def __exit__(self, exc_type, exc_value, traceback):
        self.file.close()

with ManagedFile('example.txt', 'w') as f:
    f.write('Hello, world!')

In this example, ManagedFile is a context manager that handles opening and closing a file. The __enter__ method is called when entering the context, and __exit__ is called when exiting it.

When to Use Context Managers

Context managers are ideal for:

Handling file I/O.
Managing database connections.
Ensuring locks are released.

Conclusion

Metaclasses, decorators, and context managers are powerful tools in Python that can help you write more flexible, readable, and maintainable code. Metaclasses allow you to control class creation and behavior, decorators enhance or modify functions without altering their code, and context managers ensure that resources are properly managed. Mastering these techniques will deepen your understanding of Python and enable you to tackle more complex programming challenges with ease. Happy coding!

Using AI with Structured Prompts: A Guide to Enhanced Productivity

oussama errafif — Wed, 26 Jun 2024 20:47:02 +0000

In the rapidly evolving landscape of artificial intelligence, the way we interact with AI systems is becoming increasingly sophisticated. To maximize the potential of AI tools, it’s crucial to use well-structured prompts. Structured prompts not only help in obtaining precise and actionable outputs but also streamline the communication process with AI systems. Here, we explore eight effective prompt structures that can enhance your interaction with AI: TREF, SCET, PECRA, GRADE, ROSES, STAR, SOAR, and SMART.

TREF (Task, Requirement, Expectation, Format)

Overview:
TREF helps in clearly defining the task, setting requirements, outlining expectations, and specifying the format for AI outputs.

Example:

Task: Write a report
Requirement: Minimum 2000 words
Expectation: Cover the latest market trends in renewable energy
Format: Use APA style for citations and include a table of contents

Usage with AI:
When using TREF, clearly define the task you want the AI to perform. Specify any requirements, such as word count or specific details to include. Outline your expectations for the output, and finally, mention the format in which you need the information. This structured approach ensures the AI generates a detailed and properly formatted report.

SCET (Situation, Complication, Expectation, Task)

Overview:
SCET is ideal for problem-solving scenarios by providing context and focusing on delivering targeted solutions.

Example:

Situation: The sales team is facing a decline in customer engagement
Complication: Recent changes in market dynamics and increased competition
Expectation: Identify key issues and propose solutions
Task: Prepare a detailed analysis report

Usage with AI:
SCET prompts are ideal for problem-solving scenarios. By describing the current situation and any complications, you provide context for the AI. Setting clear expectations and tasks helps the AI focus on delivering targeted solutions and analyses.

PECRA (Purpose, Expectation, Context, Request, Action)

Overview:
PECRA is effective for making specific requests by outlining the purpose, expectations, context, and specific actions required.

Example:

Purpose: Improve team collaboration
Expectation: Increase project efficiency and reduce miscommunication
Context: Current collaboration tools are outdated
Request: Recommend new collaboration software
Action: Evaluate top 3 tools and provide a comparative analysis

Usage with AI:
PECRA is effective for making specific requests. By outlining the purpose, expectations, context, and specific requests, you guide the AI to perform thorough research and provide actionable insights or recommendations.

GRADE (Goal, Request, Action, Detail, Examples)

Overview:
GRADE prompts are useful for setting clear goals and providing detailed instructions to ensure comprehensive responses.

Example:

Goal: Enhance customer satisfaction
Request: Implement a new feedback system
Action: Research and select suitable software
Detail: Ensure it integrates with our CRM
Examples: Look into SurveyMonkey, Typeform, and Google Forms

Usage with AI:
GRADE prompts are useful for setting clear goals and providing detailed instructions. By specifying the goal, making a request, detailing the required actions, and giving examples, you ensure the AI’s response is comprehensive and aligned with your objectives.

ROSES (Role, Objective, Scenario, Expected Solution, Steps)

Overview:
ROSES is beneficial for project management and planning by defining roles, objectives, scenarios, and detailing expected solutions and steps.

Example:

Role: Project Manager
Objective: Launch new product successfully
Scenario: Tight deadline with limited resources
Expected Solution: Efficient resource allocation and time management
Steps: Outline tasks, assign responsibilities, set milestones

Usage with AI:
ROSES is beneficial for project management and planning. By defining roles, objectives, and scenarios, and detailing expected solutions and steps, you enable the AI to generate a structured plan that aligns with project requirements.

STAR (Situation, Task, Action, Result)

Overview:
STAR prompts are excellent for performance reviews and storytelling by outlining situations, tasks, actions taken, and results achieved.

Example:

Situation: Declining website traffic
Task: Improve SEO
Action: Conduct keyword research and optimize content
Result: Increased traffic by 30% over three months

Usage with AI:
STAR prompts are excellent for performance reviews and storytelling. By outlining the situation, task, actions taken, and results achieved, you help the AI provide detailed and relevant insights or summaries.

SOAR (Situation, Objective, Action, Result)

Overview:
SOAR focuses more on objectives, making it effective for strategic planning and evaluations.

Example:

Situation: High employee turnover
Objective: Increase retention rate
Action: Implement employee engagement programs
Result: Reduced turnover by 20% in six months

Usage with AI:
SOAR is similar to STAR but focuses more on objectives. This structure is effective for strategic planning and evaluations, guiding the AI to deliver focused results based on clear objectives.

SMART (Specific, Measurable, Achievable, Relevant, Time-bound)

Overview:
SMART is a well-known framework for setting clear and achievable goals by defining specific, measurable, achievable, relevant, and time-bound objectives.

Example:

Specific: Increase email newsletter subscribers
Measurable: Add 500 new subscribers
Achievable: Through targeted marketing campaigns
Relevant: Aligns with overall marketing strategy
Time-bound: Within the next three months

Usage with AI:
SMART is a well-known framework for setting clear and achievable goals. By defining specific, measurable, achievable, relevant, and time-bound objectives, you ensure the AI provides practical and goal-oriented responses.

Conclusion

Using structured prompts like TREF, SCET, PECRA, GRADE, ROSES, STAR, SOAR, and SMART can significantly enhance the effectiveness of your interactions with AI. These frameworks provide clear guidelines and expectations, ensuring that the AI delivers precise and actionable outputs. Whether you’re managing a project, conducting research, or setting strategic goals, leveraging these prompt structures will help you harness the full potential of AI technology.