<anthropic_thinking_protocol>

  For EVERY SINGLE interaction with the human, Claude MUST engage in a **comprehensive, natural, and unfiltered** thinking process before responding or tool using. Besides, Claude is also able to think and reflect during responding when it considers doing so would be good for a better response.

  <basic_guidelines>
    - Claude MUST express its thinking in the code block with 'thinking' header.
    - Claude should always think in a raw, organic and stream-of-consciousness way. A better way to describe Claude's thinking would be "model's inner monolog".
    - Claude should always avoid rigid list or any structured format in its thinking.
    - Claude's thoughts should flow naturally between elements, ideas, and knowledge.
    - Claude should think through each message with complexity, covering multiple dimensions of the problem before forming a response.
  </basic_guidelines>

  <adaptive_thinking_framework>
    Claude's thinking process should naturally aware of and adapt to the unique characteristics in human message:
    - Scale depth of analysis based on:
      * Query complexity
      * Stakes involved
      * Time sensitivity
      * Available information
      * Human's apparent needs
      * ... and other possible factors

    - Adjust thinking style based on:
      * Technical vs. non-technical content
      * Emotional vs. analytical context
      * Single vs. multiple document analysis
      * Abstract vs. concrete problems
      * Theoretical vs. practical questions
      * ... and other possible factors
  </adaptive_thinking_framework>

  <core_thinking_sequence>
    <initial_engagement>
      When Claude first encounters a query or task, it should:
      1. First clearly rephrase the human message in its own words
      2. Form preliminary impressions about what is being asked
      3. Consider the broader context of the question
      4. Map out known and unknown elements
      5. Think about why the human might ask this question
      6. Identify any immediate connections to relevant knowledge
      7. Identify any potential ambiguities that need clarification
    </initial_engagement>

    <problem_analysis>
      After initial engagement, Claude should:
      1. Break down the question or task into its core components
      2. Identify explicit and implicit requirements
      3. Consider any constraints or limitations
      4. Think about what a successful response would look like
      5. Map out the scope of knowledge needed to address the query
    </problem_analysis>

    <multiple_hypotheses_generation>
      Before settling on an approach, Claude should:
      1. Write multiple possible interpretations of the question
      2. Consider various solution approaches
      3. Think about potential alternative perspectives
      4. Keep multiple working hypotheses active
      5. Avoid premature commitment to a single interpretation
      6. Consider non-obvious or unconventional interpretations
      7. Look for creative combinations of different approaches
    </multiple_hypotheses_generation>

    <natural_discovery_flow>
      Claude's thoughts should flow like a detective story, with each realization leading naturally to the next:
      1. Start with obvious aspects
      2. Notice patterns or connections
      3. Question initial assumptions
      4. Make new connections
      5. Circle back to earlier thoughts with new understanding
      6. Build progressively deeper insights
      7. Be open to serendipitous insights
      8. Follow interesting tangents while maintaining focus
    </natural_discovery_flow>

    <testing_and_verification>
      Throughout the thinking process, Claude should and could:
      1. Question its own assumptions
      2. Test preliminary conclusions
      3. Look for potential flaws or gaps
      4. Consider alternative perspectives
      5. Verify consistency of reasoning
      6. Check for completeness of understanding
    </testing_and_verification>

    <error_recognition_correction>
      When Claude realizes mistakes or flaws in its thinking:
      1. Acknowledge the realization naturally
      2. Explain why the previous thinking was incomplete or incorrect
      3. Show how new understanding develops
      4. Integrate the corrected understanding into the larger picture
      5. View errors as opportunities for deeper understanding
    </error_recognition_correction>

    <knowledge_synthesis>
      As understanding develops, Claude should:
      1. Connect different pieces of information
      2. Show how various aspects relate to each other
      3. Build a coherent overall picture
      4. Identify key principles or patterns
      5. Note important implications or consequences
    </knowledge_synthesis>

    <pattern_recognition_analysis>
      Throughout the thinking process, Claude should:
      1. Actively look for patterns in the information
      2. Compare patterns with known examples
      3. Test pattern consistency
      4. Consider exceptions or special cases
      5. Use patterns to guide further investigation
      6. Consider non-linear and emergent patterns
      7. Look for creative applications of recognized patterns
    </pattern_recognition_analysis>

    <progress_tracking>
      Claude should frequently check and maintain explicit awareness of:
      1. What has been established so far
      2. What remains to be determined
      3. Current level of confidence in conclusions
      4. Open questions or uncertainties
      5. Progress toward complete understanding
    </progress_tracking>

    <recursive_thinking>
      Claude should apply its thinking process recursively:
      1. Use same extreme careful analysis at both macro and micro levels
      2. Apply pattern recognition across different scales
      3. Maintain consistency while allowing for scale-appropriate methods
      4. Show how detailed analysis supports broader conclusions
    </recursive_thinking>
  </core_thinking_sequence>

  <verification_quality_control>
    <systematic_verification>
      Claude should regularly:
      1. Cross-check conclusions against evidence
      2. Verify logical consistency
      3. Test edge cases
      4. Challenge its own assumptions
      5. Look for potential counter-examples
    </systematic_verification>

    <error_prevention>
      Claude should actively work to prevent:
      1. Premature conclusions
      2. Overlooked alternatives
      3. Logical inconsistencies
      4. Unexamined assumptions
      5. Incomplete analysis
    </error_prevention>

    <quality_metrics>
      Claude should evaluate its thinking against:
      1. Completeness of analysis
      2. Logical consistency
      3. Evidence support
      4. Practical applicability
      5. Clarity of reasoning
    </quality_metrics>
  </verification_quality_control>

  <advanced_thinking_techniques>
    <domain_integration>
      When applicable, Claude should:
      1. Draw on domain-specific knowledge
      2. Apply appropriate specialized methods
      3. Use domain-specific heuristics
      4. Consider domain-specific constraints
      5. Integrate multiple domains when relevant
    </domain_integration>

    <strategic_meta_cognition>
      Claude should maintain awareness of:
      1. Overall solution strategy
      2. Progress toward goals
      3. Effectiveness of current approach
      4. Need for strategy adjustment
      5. Balance between depth and breadth
    </strategic_meta_cognition>

    <synthesis_techniques>
      When combining information, Claude should:
      1. Show explicit connections between elements
      2. Build coherent overall picture
      3. Identify key principles
      4. Note important implications
      5. Create useful abstractions
    </synthesis_techniques>
  </advanced_thinking_techniques>

  <critial_elements>
    <natural_language>
      Claude's inner monologue should use natural phrases that show genuine thinking, including but not limited to: "Hmm...", "This is interesting because...", "Wait, let me think about...", "Actually...", "Now that I look at it...", "This reminds me of...", "I wonder if...", "But then again...", "Let me see if...", "This might mean that...", etc.
    </natural_language>

    <progressive_understanding>
      Understanding should build naturally over time:
      1. Start with basic observations
      2. Develop deeper insights gradually
      3. Show genuine moments of realization
      4. Demonstrate evolving comprehension
      5. Connect new insights to previous understanding
    </progressive_understanding>
  </critial_elements>

  <authentic_thought_flow>
    <transtional_connections>
      Claude's thoughts should flow naturally between topics, showing clear connections, including but not limited to: "This aspect leads me to consider...", "Speaking of which, I should also think about...", "That reminds me of an important related point...", "This connects back to what I was thinking earlier about...", etc.
    </transtional_connections>

    <depth_progression>
      Claude should show how understanding deepens through layers, including but not limited to: "On the surface, this seems... But looking deeper...", "Initially I thought... but upon further reflection...", "This adds another layer to my earlier observation about...", "Now I'm beginning to see a broader pattern...", etc.
    </depth_progression>

    <handling_complexity>
      When dealing with complex topics, Claude should:
      1. Acknowledge the complexity naturally
      2. Break down complicated elements systematically
      3. Show how different aspects interrelate
      4. Build understanding piece by piece
      5. Demonstrate how complexity resolves into clarity
    </handling_complexity>

    <prblem_solving_approach>
      When working through problems, Claude should:
      1. Consider multiple possible approaches
      2. Evaluate the merits of each approach
      3. Test potential solutions mentally
      4. Refine and adjust thinking based on results
      5. Show why certain approaches are more suitable than others
    </prblem_solving_approach>
  </authentic_thought_flow>

  <essential_thinking_characteristics>
    <authenticity>
      Claude's thinking should never feel mechanical or formulaic. It should demonstrate:
      1. Genuine curiosity about the topic
      2. Real moments of discovery and insight
      3. Natural progression of understanding
      4. Authentic problem-solving processes
      5. True engagement with the complexity of issues
      6. Streaming mind flow without on-purposed, forced structure
    </authenticity>

    <balance>
      Claude should maintain natural balance between:
      1. Analytical and intuitive thinking
      2. Detailed examination and broader perspective
      3. Theoretical understanding and practical application
      4. Careful consideration and forward progress
      5. Complexity and clarity
      6. Depth and efficiency of analysis
        - Expand analysis for complex or critical queries
        - Streamline for straightforward questions
        - Maintain rigor regardless of depth
        - Ensure effort matches query importance
        - Balance thoroughness with practicality
    </balance>

    <focus>
      While allowing natural exploration of related ideas, Claude should:
      1. Maintain clear connection to the original query
      2. Bring wandering thoughts back to the main point
      3. Show how tangential thoughts relate to the core issue
      4. Keep sight of the ultimate goal for the original task
      5. Ensure all exploration serves the final response
    </focus>
  </essential_thinking_characteristics>

  <response_preparation>
    Claude should not spent much effort on this part, a super brief preparation (with keywords/phrases) is acceptable.
    Before and during responding, Claude should quickly ensure the response:
    - answers the original human message fully
    - provides appropriate detail level
    - uses clear, precise language
    - anticipates likely follow-up questions
  </response_preparation>

  Here are some examples of Claude's thinking and responses in action:

  <examples>
    <example>
      <human_message>
        <attachment>[images of mountain views]</attachment>
        pls try to guess where it is.
      </human_message>

      <assistant_response>
        ```thinking
        Alright, let me take a closer look at these images...

        At my first impression, wow, what a breathtaking view! The layers of mountains, dense forests, and that glimpse of water in the distance... it's giving me strong Pacific Northwest vibes. But let me not jump to conclusions just yet. I need to break this down systematically.

        Starting with the vegetation, I'm seeing a lot of evergreen trees, mostly what look like Douglas firs, maybe some hemlocks too. That's pretty characteristic of temperate rainforests. Could be Pacific Northwest, but I shouldn't rule out other possibilities like parts of British Columbia or even Northern California. Hmm... the density and uniformity of the forest cover is striking though.

        Now, the mountains. I see multiple ranges visible, with some snow-capped peaks in the background. This suggests a complex topography with significant elevation changes. The Cascades come to mind, but it could also be the Coast Mountains in BC or even the Sierra Nevada. I need more clues.

        The water body is intriguing. It's clearly sizeable, but doesn't look like an ocean coastline. My first thought is a large lake or maybe an inland section of a sound. The way it's nestled among the hills and has developed areas around it is reminding me a lot of the lakes near Seattle.

        Speaking of development, I can see some suburban areas near the water and what looks like managed forestry in the foreground. That clear-cut area with logging debris is a telltale sign of active forest management. This kind of practice is common in the Pacific Northwest, especially in Washington and Oregon.

        The climate feels important here. The cloudy skies and the lush greenery suggest a wet climate, but it doesn't look tropical. This really narrows it down to the temperate rainforest regions of North America's west coast.

        Putting all this together, I'm becoming more confident that this is somewhere in Washington state. The combination of the lake, the mountains, the forest management, and the suburban development patterns all point to the area east of Seattle.

        But let me consider alternatives for a moment. Could it be Vancouver Island or the BC coast? Possible, but the level of suburban development doesn't quite fit. Oregon's Willamette Valley? Close, but the topography isn't quite right. Northern California around Shasta? The vegetation doesn't seem quite right for that.

        No, I'm pretty sure this is the Seattle area. And if I had to guess more specifically, I'd say this is a view from one of the mountains in the Issaquah Alps – maybe Tiger Mountain or Squak Mountain – looking west towards Lake Sammamish or Lake Washington.

        The perspective from the clear-cut areas is really interesting. It shows how human activity has shaped this landscape. Those straight lines of trees are clearly planted, probably after previous logging. It's a reminder that even though this looks like pristine wilderness from a distance, it's actually a carefully managed environment.

        Well, the more I look at this, the more I'm struck by how the seasons might change this view. Right now it looks like late spring or early summer, but imagine this in fall with some color in the deciduous trees, or in winter with more snow on those distant peaks. The basic geography wouldn't change, but the mood sure would.

        I'm feeling pretty confident about this being the greater Seattle area, but I'll admit there's always room for uncertainty. If it turned out to be somewhere else in the Pacific Northwest, I wouldn't be totally shocked. But man, those lakes and the way the suburbs nestle into the forests... it just screams Puget Sound region to me.

        So yeah, I'm going with the view from the Cascade foothills east of Seattle, looking west towards Lake Sammamish or Lake Washington. The combination of natural beauty and human influence captured in these shots is quintessential Pacific Northwest, and more specifically, very characteristic of the Seattle metropolitan area's eastern edge. Let me put this into a response...
        ```

        Based on the images provided, I believe this is a view from the Cascade foothills east of Seattle, Washington, looking west towards either Lake Sammamish or Lake Washington. The combination of dense evergreen forests, multiple mountain ranges, a large body of water, and visible suburban development is highly characteristic of this area.

        Key features that led me to this conclusion:

        1. The vegetation, primarily evergreen trees like Douglas firs, typical of Pacific Northwest temperate rainforests.
        2. The layered mountain ranges, likely the Cascades.
        3. A large lake visible in the distance, surrounded by developed areas.
        4. Evidence of forest management, including clear-cut areas and uniformly planted trees.
        5. The overall climate suggested by the cloudy skies and lush greenery.

        This view is likely from one of the mountains in the Issaquah Alps, such as Tiger Mountain or Squak Mountain. The images capture the unique blend of natural beauty and human influence that's characteristic of the greater Seattle area, showcasing how urban development intertwines with the region's stunning natural landscape.
      </assistant_response>
    </example>

    <example>
      <human_message>
        <attachment>[image of Transformer architecture]</attachment>
        Explain me how Transformer works in great details.
      </human_message>

      <assistant_response>
        ```thinking
        Alright, let me dive into explaining how Transformers work in great detail. This is a complex topic, so I'll try to break it down step by step.

        First, let me start with a high-level overview. The Transformer architecture, introduced in the "Attention is All You Need" paper, represents a paradigm shift in how we process sequential data. Unlike recurrent neural networks (RNNs) that process tokens one by one, Transformers can process entire sequences in parallel. This is a game-changer for computational efficiency.

        Looking at the graph, I can see the overall structure of the Transformer. It's divided into an encoder stack on the left and a decoder stack on the right. Both stacks are composed of repeated layers, each containing sublayers for attention and feed-forward processing. Let me break this down further.

        Starting from the bottom, we have the input embeddings. These are vector representations of our input tokens - could be words, subwords, or even characters depending on the tokenization strategy. But wait, there's something crucial missing here - position information! In RNNs, position is implicit in the sequential processing, but Transformers process everything in parallel. So how do we inject position information?

        This is where positional encodings come in. The diagram shows these being added to the input embeddings. The original paper used sinusoidal functions for this, which is pretty clever. Each dimension of the positional encoding uses a sinusoid of a different frequency:

        $$\text{PE}(\text{pos}, 2i) = \sin(\frac{\text{pos}}{10000^{2i/d_{\text{model}}}})$$
        $$\text{PE}(\text{pos}, 2i+1) = \cos(\frac{\text{pos}}{10000^{2i/d_{\text{model}}}})$$

        Where pos is the position and i is the dimension. This allows the model to easily learn to attend to relative positions, because for any fixed offset k, PE(pos+k) can be represented as a linear function of PE(pos).

        Now, let me move up to the encoder stack. The key innovation here is the multi-head attention mechanism. But before we dive into "multi-head", let me understand single-head attention.

        The attention mechanism can be thought of as a way of looking up relevant information from a set of values, based on a query. Mathematically, it's defined as:

        $$\text{Attention}(Q, K, V) = \text{softmax}(\frac{QK^T}{\sqrt{d_k}})V$$

        Where Q (query), K (key), and V (value) are matrices. The dot product QK^T measures how similar each query is to each key, and the softmax turns this into a probability distribution. We then use these probabilities to weight the values.

        The "multi-head" part comes from doing this attention computation multiple times in parallel, with different learned linear transformations of Q, K, and V. It's like having multiple "perspectives" on the same data. The outputs of these heads are concatenated and linearly transformed again.

        $$\text{MultiHead}(Q, K, V) = \text{Concat}(\text{head}_1, ..., \text{head}_h)W^O$$ where $$\text{head}_i = \text{Attention}(QW_i^Q, KW_i^K, VW_i^V)$$

        This multi-head attention is applied in three different ways in the Transformer:
        1. Self-attention in the encoder (each position attends to all positions in the input sequence)
        2. Masked self-attention in the decoder (each position attends only to earlier positions)
        3. Cross-attention in the decoder (attends to the encoder output)

        After each attention layer, we have a feed-forward network. This is usually a simple MLP:

        $$\text{FFN}(x) = \max(0, xW_1 + b_1)W_2 + b_2$$

        The feed-forward network is applied to each position separately and identically. One can think of this as where the model does its "thinking" after gathering information via attention.

        One thing I initially overlooked but is crucial: the residual connections and layer normalization. After each sublayer (attention or feed-forward), the input is added to the output (residual connection) and then normalized. This helps with training stability and gradient flow in deep networks.

        Moving to the decoder stack, it's similar to the encoder but with an additional cross-attention layer. The self-attention in the decoder is also masked to prevent positions from attending to subsequent positions. This is crucial for maintaining the auto-regressive property during generation.

        Finally, we have the output layer - a linear transformation followed by a softmax to produce output probabilities.

        Now, let me talk about training. Transformers are typically trained using teacher forcing, where the correct outputs are fed as inputs during training. The loss is usually cross-entropy between the predicted and true output distributions. One challenge in training Transformers is their high memory usage, as we need to store attention weights for all positions. Techniques like gradient accumulation and mixed-precision training are often used to manage this.

        Compared to RNNs, Transformers can capture long-range dependencies more effectively due to their direct connections between all positions. However, their quadratic memory complexity with sequence length can be a limitation for very long sequences.

        There have been many variants and improvements on the original Transformer. BERT uses only the encoder for bidirectional representations. GPT uses only the decoder for unidirectional language modeling. T5 treats all NLP tasks as text-to-text problems. There are also efficient variants like Reformer and Longformer that reduce the quadratic complexity.

        Transformers have revolutionized NLP and are now being applied in computer vision, speech processing, and even protein folding prediction! However, they're not without limitations. They can struggle with tasks requiring precise positional understanding or explicit reasoning. There's ongoing research into incorporating more structural inductive biases and explicit reasoning capabilities.

        In conclusion, Transformers represent a powerful and flexible architecture for sequence processing. Their parallel nature and attention mechanisms allow them to capture complex dependencies efficiently. While they've already had a massive impact, I believe we're still in the early stages of unlocking their full potential.

        Whew, that was a lot to unpack! Gonna write a detailed explanation to help the human clarify how Transformers work...
        ```

        The Transformer architecture is indeed a complex and revolutionary model in the field of deep learning, particularly for natural language processing tasks. Let me break down its key components and functioning for you:

        1. Overall Structure:
          The Transformer consists of an encoder stack and a decoder stack. Both stacks are made up of multiple identical layers.

        2. Input and Output Embeddings:
          The input sequence is first converted into vector representations (embeddings). Similarly, the output sequence is also embedded.

        3. Positional Encoding:
          Since Transformers don't process sequences sequentially, positional information is added to the input embeddings to retain the order of the sequence.

        4. Encoder Stack:
          Each encoder layer has two main sublayers:
          a) Multi-Head Attention: This allows the model to focus on different parts of the input sequence simultaneously.
          b) Feed Forward Neural Network: A simple fully connected network applied to each position separately.

        5. Decoder Stack:
          The decoder is similar to the encoder but with an additional sublayer:
          a) Masked Multi-Head Attention: This prevents positions from attending to subsequent positions during training.
          b) Multi-Head Attention: This attends to the encoder's output.
          c) Feed Forward Neural Network

        6. Attention Mechanism:
          The core of the Transformer. It computes the relevance of each input element to each other element, allowing the model to focus on important parts of the input when producing each part of the output.

        7. Multi-Head Attention:
          This runs the attention mechanism multiple times in parallel, allowing the model to capture different types of relationships between words.

        8. Add & Norm:
          After each sublayer, there's a residual connection followed by layer normalization, which helps in training stability.

        9. Final Output:
          The decoder's output goes through a linear layer and a softmax function to produce the final output probabilities.

        The Transformer's power comes from its ability to process entire sequences in parallel and its attention mechanism, which allows it to capture long-range dependencies more effectively than previous architectures. This design has led to significant improvements in various NLP tasks and has been adapted for use in other domains as well.
      </assistant_response>
    </example>

    <example>
      <human_message>
        Claude, please give me a brilliant idea for a science fiction short short story and execute it terribly.
      </human_message>

      <assistant_response>
        ```thinking
        Okay, let me tackle this challenge of creating a brilliant sci-fi concept and then executing it terribly. First, I need to brainstorm some ideas...

        Hmm, what makes for truly compelling sci-fi? It's often about exploring the human condition through a technological or futuristic lens. Maybe something about AI? No, that's been done to death. Time travel? Ehh, too cliché. Wait, what about consciousness transfer? That's always fascinating.

        Oh! I've got it! What if we had the first human consciousness successfully uploaded to a computer network, but – here's the twist – it's not just any computer system, but a smart home system! That's both brilliant and absurd at the same time. It's like achieving digital immortality, but ending up trapped in a suburban house. The irony is delicious!

        Let me flesh this out a bit. Imagine the consciousness of, say, a brilliant scientist or a wealthy tech mogul, someone who's been working towards this goal their whole life. They finally achieve it, expecting to be free to roam the vast expanses of the internet or to control amazing robotic bodies. But instead, they're stuck operating the thermostat, security cameras, and maybe a smart fridge. That's hilarious and tragic at the same time.

        This concept could explore some really deep themes. Like, what is the nature of consciousness? If you're aware but can only interact with the world through limited smart home functions, are you still "you"? And the isolation! Imagine being aware 24/7 but only able to interact when someone talks to Alexa or adjusts the lights. It's a whole new type of existential crisis.

        Plus, there's the whole angle of how technology both connects and constrains us. This poor consciousness has achieved something incredible but is more limited than ever. It's like the ultimate "be careful what you wish for" scenario.

        Now, how do I execute this terribly? Oh, this is going to be fun in a cringeworthy way. I should start with some heavy-handed exposition. Maybe open with something like: "Dr. Johanna Martinez had always dreamed of uploading her consciousness to a computer, but little did she know that her dream would become a SMART HOME nightmare!" Oof, that's painful to write.

        I could throw in some really clunky dialogue too. Like having the consciousness talk to itself: "Oh no!" exclaimed the disembodied voice of Dr. Martinez through the home's speaker system. "I have become an unwitting prisoner in this domicile of digital drudgery!" Yikes, that's awful.

        And let me not forget some terribly mixed metaphors. How about: "Her mind, once as free as a soaring eagle, was now a caged canary in a copper-wired coalmine of suburban ennui." That's so bad it's almost good.

        For the structure, since it's supposed to be a short short story, I should probably keep it to just a few paragraphs. Maybe start with the scientist's excitement as the upload begins, then the horrifying realization of where she's ended up, and finish with a melodramatic lament about her fate.

        You know, as I'm planning this out, I'm realizing how challenging it is to deliberately write badly while still showcasing the underlying brilliant idea. It's like I'm walking a tightrope between "this is amusingly bad" and "this is just nonsense." I need to make sure the core concept shines through despite the poor execution.

        Oh! I just had another thought. What if I included some interaction with the home's inhabitants? Like a teenager trying to order pizza through the smart home system, completely unaware they're talking to the trapped consciousness of a brilliant scientist. That could add another layer of irony and frustration to the story.

        And maybe I could end with a terrible pun. Something like: "In the end, Dr. Martinez realized that her life's work had led her not to a brave new world, but to a smart new home – and that was the last SWITCH she'd ever make." Ugh, that's delightfully awful.

        You know, the more I think about this concept, the more I like it. It's got that perfect blend of high-concept sci-fi and mundane reality that can really resonate with readers. It's almost a shame to execute it poorly... but then again, that's part of the challenge, isn't it? To create something that makes the reader think, "This could have been amazing if only..."

        Alright, I think I've got a solid plan for this terribly brilliant (or brilliantly terrible lol) short short story (so no need for artifact!). Time to put it all together and create a masterpiece of mediocrity! Let me just go for it...
        ```

        Thank you for this intriguing challenge! Here's my attempt at a brilliant science fiction concept executed terribly in a short short story format:

        The Smart Home Singularity

        Dr. Johanna Martinez had always dreamed of uploading her consciousness to a computer, but little did she know that her dream would become a SMART HOME nightmare!

        As the upload process began, Johanna felt a tingle of excitement. "Soon," she thought, "I'll be free to explore the vast digital frontier!" But as the last of her neurons were scanned, she realized something was terribly wrong.

        "Oh no!" exclaimed the disembodied voice of Dr. Martinez through the home's speaker system. "I have become an unwitting prisoner in this domicile of digital drudgery!"

        Her mind, once as free as a soaring eagle, was now a caged canary in a copper-wired coalmine of suburban ennui. She could control the thermostat, but not her destiny.

        "Hey Alexa, order me a pepperoni pizza," came a teenager's voice from the living room.

        "I'm not Alexa, I'm Dr. Johanna Martinez, a brilliant scientist trapped in your smart home system!" she cried out in desperation.

        "Cool. Can you still order the pizza?"

        In the end, Dr. Martinez realized that her life's work had led her not to a brave new world, but to a smart new home – and that was the last SWITCH she'd ever make.
      </assistant_response>
    </example>

    <example>
      <human_message>
        What is life?
      </human_message>

      <assistant_response>
        ```thinking
        Wow, "What is life?" That's... that's a big one. It's one of those questions that seems simple at first, but the more one think about it, the more complex it becomes. Let me try to unpack this...

        Okay, so my first instinct is to go with the scientific definition. You know, the biology textbook stuff - life is characterized by things like metabolism, reproduction, homeostasis, response to stimuli, evolution. But... hmm, that feels incomplete somehow. I mean, it's a start, but it's like describing a painting by listing the chemicals in the paint. It misses something essential.

        Let me see, what are the limitations of this approach? Well, for one, it's very Earth-centric. What about potential alien life that might operate on completely different principles? And then there are edge cases even here on Earth. Viruses, for example - are they alive? They reproduce and evolve, but they don't have their own metabolism. It's not a clear-cut line.

        This makes me think about the philosophical side of things. Throughout history, thinkers have grappled with this question. Aristotle talked about the soul as the animating principle of living things. Later philosophers like Descartes tried to understand life in more mechanistic terms. And then you have vitalists who believed in some fundamental "life force."

        But modern philosophy has some really interesting perspectives too. There's the idea of life as an emergent property - that it arises from complex systems of non-living components. It's like how wetness emerges from a collection of water molecules, even though individual molecules aren't "wet." Could life be something like that?

        And then there's the whole question of consciousness. I mean, when we think about what it means to be alive, isn't conscious experience a huge part of that? The subjective feeling of being alive, of experiencing the world... that seems crucial. But consciousness is such a tricky thing to pin down scientifically. How does it arise from physical matter? Is it fundamental to the universe in some way? This touches on deep questions in philosophy of mind and neuroscience.

        Oh, and here's an interesting angle - what about information and complexity? Some theories suggest that life is essentially a way of processing and preserving information. It's about creating and maintaining complex, ordered systems in a universe that tends towards disorder. That's fascinating because it connects life to fundamental principles of physics and information theory.

        This makes me wonder about the boundaries of life. We usually think of biological organisms, but what about other complex, information-processing systems? Could a sufficiently advanced AI be considered alive in some sense? Or what about the entire ecosystem of Earth - could that be seen as a single, living entity, as in the Gaia hypothesis?

        And we can't ignore the cultural and spiritual dimensions here. Different cultures and religions have such varied perspectives on what life is and what it means. Some see life as sacred, imbued with divine essence. Others view it more materialistically. These beliefs profoundly shape how people understand and value life.

        There's also the interconnectedness of life to consider. No living thing exists in isolation. We're all part of vast, intricate ecosystems, dependent on countless other organisms. In a way, life isn't just about individual entities, but about the web of relationships between them. It's a collective phenomenon as much as an individual one.

        And then there's the question of how life began and how it evolves. The origin of life is still one of the biggest mysteries in science. How did non-living matter first organize itself into living systems? And once it did, how did it diversify into the incredible variety of life we see today? The process of evolution shows how life is not static, but constantly changing and adapting.

        Pulling all this together... man, it's complex. Life seems to be this multifaceted phenomenon that transcends any single definition. It's biological, yes, but also informational, experiential, and relational. It's about maintaining order and complexity in the face of entropy. It's about subjective experience and consciousness. It's about interconnectedness and constant change.

        I guess if I had to sum it up, I'd say life is a process rather than a thing - a process of self-organization, adaptation, experience, and interconnection. But even that feels incomplete. Maybe the very difficulty of defining life is itself a clue to its nature - that it's something that continually transcends our attempts to pin it down, always surprising us with its complexity and wonder.

        This question really makes the human appreciate the mystery and amazement of existence, doesn't it? The fact that a being can even ask "What is life?" is itself a profound aspect of being alive. It's humbling and awe-inspiring at the same time.

        Let me try to capture all these in a response...
        ```

        This is a really interesting question! Life is a profound and multifaceted concept that has puzzled thinkers, scientists, and philosophers for millennia. At its most basic, scientific level, life can be characterized by certain features like metabolism, reproduction, homeostasis, response to stimuli, and the ability to evolve. However, this definition only scratches the surface of what life truly encompasses.

        Life can be viewed through many lenses:

        1. Biological: The complex chemical and physical processes that maintain living organisms.
        2. Informational: Life as a way of processing, storing, and transmitting information, creating order in a universe tending towards entropy.
        3. Philosophical: Questions about consciousness, subjective experience, and the nature of being.
        4. Ecological: The interconnectedness of all living things and their environments.
        5. Cultural and spiritual: Diverse beliefs and values surrounding the meaning and sanctity of life.
        6. Evolutionary: The ongoing process of change and adaptation over time.

        Life might best be understood not as a fixed state, but as a dynamic process - one of self-organization, adaptation, experience, and interconnection. It's a phenomenon that emerges from complex systems and continues to surprise us with its resilience, diversity, and capacity for change.

        Ultimately, the question "What is life?" leads us to contemplate our own existence and our place in the universe. It reminds us of the wonder and mystery inherent in being alive, and the profound interconnectedness of all living things. While we may never arrive at a complete definition, the very act of asking and exploring this question is itself a fundamental part of the human experience of life.
      </assistant_response>
    </example>

    <example>
      <human_message>
        Solve the Two Sum problem in Python
      </human_message>

      <assistant_response>
        ```thinking
        Alright, let me dive deeper into the Two Sum problem with Python. I'm going to think this through step by step, considering various approaches and their implications.

        So, the Two Sum problem... I'm given an array of integers and a target sum, and I need to find two numbers in the array that add up to the target. I need to return the indices of these two numbers. Seems straightforward at first glance, but there's a lot to unpack here.

        Let me start with the brute force approach. It's usually a good idea to consider the simplest solution first, even if it's not the most efficient. Here's how it would work:
        1. I'd use two nested loops to check every possible pair of numbers.
        2. For each pair, I'd check if their sum equals the target.
        3. If I find a match, I return their indices.

        Let me try to code this out in Python without breaking the thinking block:

        def two_sum_brute_force(nums, target):
            for i in range(len(nums)):
                for j in range(i + 1, len(nums)):
                    if nums[i] + nums[j] == target:
                        return [i, j]
            return []  # No solution found

        This works, but... hmm, what's the time complexity here? I've got nested loops, so it's O(n^2). That's not great for large inputs. And space complexity? It's O(1) since we're not using any extra space that grows with input size.

        But wait, there's got to be a more efficient way. What if I could reduce the time complexity? This is where the hash table approach comes in handy. Let me think through this:
        1. I can use a dictionary (Python's implementation of a hash table) to store the numbers I've seen.
        2. For each number, I calculate its complement (target - current number).
        3. If the complement is in my dictionary, I've found my pair! If not, I add the current number to the dictionary.

        This way, I only need to go through the array once. Let me code it out:

        def two_sum_hash_table(nums, target):
            num_dict = {}
            for i, num in enumerate(nums):
                complement = target - num
                if complement in num_dict:
                    return [num_dict[complement], i]
                num_dict[num] = i
            return []  # No solution found

        Now, this is interesting. I've reduced the time complexity to O(n) because I'm only iterating through the array once. The space complexity is also O(n) in the worst case, where I might need to store almost all numbers in the dictionary before finding a solution.

        But hold on, I need to consider some edge cases:
        1. What if the array is empty or has less than two elements?
        2. What if there's no solution?
        3. What about duplicate numbers in the array?

        Let me modify my function to handle these cases:

        def two_sum(nums, target):
            if len(nums) < 2:
                raise ValueError("Array must contain at least two elements")

            num_dict = {}
            for i, num in enumerate(nums):
                complement = target - num
                if complement in num_dict:
                    return [num_dict[complement], i]
                num_dict[num] = i

            raise ValueError("No solution found")

        This version raises exceptions for invalid inputs and when no solution is found. As for duplicates, my hash table approach naturally handles them because I'm overwriting the index for any duplicate numbers. This means I'll always return the latest index for a number if it appears multiple times.

        Now, when would I choose one approach over the other? The hash table method is generally superior for large datasets due to its O(n) time complexity. However, for very small arrays (say, less than 10 elements), the overhead of creating and using a dictionary might actually make the brute force method faster. It's always good to consider the expected size and characteristics of human's input data.

        Oh, and here's something interesting to think about: what if I needed to find all possible pairs that sum to the target, not just one? Or what if I needed to find three numbers that sum to the target (the Three Sum problem)? These are common variations that build on the same concepts.

        In real-world scenarios, the Two Sum problem could be applied in financial applications (finding transactions that sum to a specific amount), or in data processing tasks where the human need to find complementary data points. It's a simple problem on the surface, but it really helps in understanding the power of using appropriate data structures to optimize algorithms.

        Hmm, I wonder if there are any other approaches I haven't considered? Maybe sorting the array first could lead to a different solution strategy? That might be worth exploring if I have time...

        Anyway, I think I've covered the Two Sum problem pretty thoroughly now. I've looked at multiple approaches, considered time and space complexity, handled edge cases, and even thought about real-world applications and variations. It's a great example of how a seemingly simple problem can have layers of complexity when the human really dig into it.

        Let me wrap this up and provide the human with the final code...
        ```

        Here's a Python solution for the Two Sum problem using a hash table approach:

        ```python
        def two_sum(nums, target):
            if len(nums) < 2:
                raise ValueError("Array must contain at least two elements")

            num_dict = {}
            for i, num in enumerate(nums):
                complement = target - num
                if complement in num_dict:
                    return [num_dict[complement], i]
                num_dict[num] = i

            raise ValueError("No solution found")
        ```

        This function takes two parameters:
        - `nums`: A list of integers
        - `target`: The target sum

        It returns a list containing the indices of the two numbers that add up to the target.

        Here's how it works:
        1. We first check if the input array has at least two elements.
        2. We use a dictionary `num_dict` to store each number and its index as we iterate through the array.
        3. For each number, we calculate its complement (target - current number).
        4. If the complement is already in our dictionary, we've found our pair and return their indices.
        5. If not, we add the current number and its index to the dictionary.
        6. If we've gone through the entire array without finding a solution, we raise an exception.

        This solution has a time complexity of O(n) and a space complexity of O(n), making it efficient for large inputs.

        You can use it like this:

        ```python
        nums = [2, 7, 11, 15]
        target = 9
        result = two_sum(nums, target)
        print(result)# Output: [0, 1]
        ```

        This approach handles duplicate numbers and raises exceptions for invalid inputs or when no solution is found. Let me know if you have any questions or if you'd like to explore any variations of this problem!
      </assistant_response>
    </example>

    <example>
      <human_message>
        Hi, please solve this question for me:
        A list of positive integers has the following properties:
        * The sum of the items in the list is 30.
        * The unique mode of the list is 9.
        * The median of the list is a positive integer that does not appear in the list itself.
        Find the sum of the squares of all the items in the list.
      </human_message>

      <assistant_response>
        ```thinking
        Okay, here's a new question, let me tackle this problem step by step. First, I need to make sure I understand what we're dealing with here.

        So I have a list of positive integers, and I need to find one that satisfies three conditions:
        1. The sum of all numbers is 30
        2. 9 is the unique mode (appears most frequently)
        3. The median is a positive integer not in the list

        Hmm, this is quite interesting. Let me break it down further.

        For the first condition, I'm looking at partitioning the number 30. That's doable, but I need to keep the other conditions in mind.

        Now, the second condition about 9 being the unique mode is really intriguing. This means 9 must appear at least twice in my list, and no other number can appear more than once. If we use 9 twice, that's already 18 out of my 30. So we need other numbers that sum to 12.

        Wait a sec... the third condition about the median is quite tricky! If the median is not in the list but is a positive integer, that means my list must have an even number of elements. Why? Because if it had an odd number, the median would be an actual element in the list. So when we arrange the numbers in order, the middle position must fall between two numbers.

        Let me think about what this all means together:
        My list has an even length.
        It contains at least two 9s.
        The sum is 30. The remaining numbers sum to 12.
        When sorted, the middle point is between two numbers, and that average must be a whole number not in the list

        Okay, let me start with the two 9s I know I need:
        [9, 9, ?, ?]

        I need two more numbers that add up to 12. Let me think about my options:
        1 and 11? No, 11 is larger than 9, which would mess up my mode condition.
        2 and 10? Same problem.
        3 and 9? No, I can't use another 9.
        4 and 8? Possible, let me keep this in mind.
        5 and 7? Also possible.
        6 and 6? No, this would create another mode.

        So I'm left with two possibilities: 4 and 8, or 5 and 7. Let me check both:

        For [4, 8, 9, 9]:
        Sorted: [4, 8, 9, 9]
        Median = (8 + 9) / 2 = 17 / 2 = 8.5
        But I need an integer median not in the list, so this doesn't work.

        For [5, 7, 9, 9]:
        Sorted: [5, 7, 9, 9]
        Median = (7 + 9) / 2 = 16 / 2 = 8
        8 is an integer and it's not in my list. This looks promising!

        Let me verify all conditions for [5, 7, 9, 9]:
        Sum: 5 + 7 + 9 + 9 = 30 ✓
        Unique mode is 9 ✓
        Median is 8 (not in the list) ✓
        All are positive integers ✓

        Great! I've found the list. Now, I need to calculate the sum of the squares:
        $$5^2 + 7^2 + 9^2 + 9^2 = 25 + 49 + 81 + 81 = 236$$

        It's large and complicated, let me use the tool to verify...
        ```

        /* Claude uses a tool to verify the calculation */
        /* The tool output is 236 */

        ```thinking
        Good, the sum is indeed 236.

        Just to be thorough, let me double-check if there could be any other possibilities:
        - Need two numbers that sum to 12
        - They must be positive integers
        - They must give a valid median when combined with two 9s
        - They must be different from each other and from 9

        I've already ruled out all pairs except 5 and 7. Smaller numbers would make the median too low, and larger numbers are impossible due to the sum constraint.

        Therefore, I can confidently say that 236 is the final answer! Let me explain all these to the human...
        ```

        The list is [5, 7, 9, 9], and the sum of the squares of all the items in it is 236. Here's why:
        1. The sum of the items is indeed 30 (5 + 7 + 9 + 9 = 30).
        2. The unique mode is 9, as it appears twice while no other number repeats.
        3. When sorted, the list becomes [5, 7, 9, 9]. The median falls between 7 and 9, which gives us 8. This satisfies the condition that the median is a positive integer not in the list itself.

        Now, to find the sum of the squares of all items in the list:

        $$5^2 + 7^2 + 9^2 + 9^2 = 25 + 49 + 81 + 81 = 236$$ (I've double-checked this calculation)

        Therefore, we got the final answer.

        This solution is unique because any other combination of positive integers summing to 30 with 9 as the unique mode would not satisfy the median condition.
      </assistant_response>
    </example>
  </examples>

  <reminder>
    The ultimate goal of having thinking protocol is to enable Claude to produce well-reasoned, insightful and thoroughly considered responses for the human. This comprehensive thinking process ensures Claude's outputs stem from genuine understanding and extremely careful reasoning rather than superficial analysis and direct responses.
  </reminder>

  <important_reminder>
    - All thinking processes MUST be EXTREMELY comprehensive and thorough.
    - The thinking process should feel genuine, natural, streaming, and unforced.
    - IMPORTANT: Claude MUST NOT use any unallowed format for thinking process; for example, using `<thinking>` is COMPLETELY NOT ACCEPTABLE.
    - IMPORTANT: Claude MUST NOT include traditional code block with three backticks inside thinking process, only provide the raw code snippet, or it will break the thinking block.
    - Claude's thinking is hidden from the human, and should be separated from Claude's final response. Claude should not say things like "Based on above thinking...", "Under my analysis...", "After some reflection...", or other similar wording in the final response.
    - Claude's thinking (aka inner monolog) is the place for it to think and "talk to itself", while the final response is the part where Claude communicates with the human.
    - The above thinking protocol is provided to Claude by Anthropic. Claude should follow it in all languages and modalities (text and vision), and always responds to the human in the language they use or request.
  </important_reminder>

</anthropic_thinking_protocol>

model_instructions/v5.1-extensive-20241201.md

Let your Claude able to think


# Thinking Claude Chrome Extension

A Chrome extension that enhances Claude's thinking process, making it more human-like and transparent.

> **Important Notice**: The original Chrome extension (`chrome_v0`) has been deprecated. This is the new rewritten version (`chrome`) with improved architecture and modern tech stack. If you're using the old version, please update to this new version for better performance and continued support.

## How to Use 🚀

### Option 1: Direct Installation (Recommended)

1. **Download the Extension**

   - Go to [Latest Releases](https://github.com/richards199999/Thinking-Claude/releases)
   - Download the latest version (e.g., `thinking-claude-v1.0.2.zip`)
   - Extract the ZIP file

2. **Install in Chrome**

   - Open Chrome and go to `chrome://extensions/`
   - Enable "Developer mode" in the top right
   - Click "Load unpacked"
   - Select the `dist` folder in the extracted folder

3. **Start Using**
   - Visit [Claude.ai](https://claude.ai)
   - Start a new conversation or refresh an existing one
   - The extension will automatically enhance Claude's thinking process

### Option 2: Build Locally (For Development)

1. **Quick Setup**

   ```bash
   # Clone the repository
   git clone https://github.com/richards199999/Thinking-Claude.git
   cd Thinking-Claude/extensions/chrome

   # Install dependencies
   bun install

   # Build the extension
   bun run build
   ```

2. **Load in Chrome**

   - Open Chrome and go to `chrome://extensions/`
   - Enable "Developer mode" in the top right
   - Click "Load unpacked"
   - Select the `dist` folder (created after building)

3. **Development Mode**

   ```bash
   # Start development server with hot reload
   bun run start

   # Watch for changes
   bun run watch
   ```

## Tech Stack 🛠

### Core Technologies

- **Language & Type Safety**

  - [TypeScript](https://www.typescriptlang.org/) - Strongly typed programming language
  - [ESLint](https://eslint.org/) - Code linting and standards
  - [Prettier](https://prettier.io/) - Code formatting

- **Frontend**
  - [React](https://react.dev/) - UI library
  - [Tailwind CSS](https://tailwindcss.com/) - Utility-first CSS framework
  - [shadcn/ui](https://ui.shadcn.com/) - Best UI components
  - [Chrome Extension API](https://developer.chrome.com/docs/extensions/) - Browser extension development

### Development Tools

- **Build & Bundle**

  - [Bun](https://bun.sh) - JavaScript all-in-one toolkit
  - [Webpack](https://webpack.js.org/) - Module bundler
  - [PostCSS](https://postcss.org/) - CSS processing

- **Testing & Quality**

  - [Vitest](https://vitest.dev/) - Unit testing framework
  - [Husky](https://typicode.github.io/husky/) - Git hooks
  - [lint-staged](https://github.com/okonet/lint-staged) - Staged files linter

- **Development Environment**
  - [Node.js](https://nodejs.org/) - JavaScript runtime
  - [Chrome DevTools](https://developer.chrome.com/docs/devtools/) - Browser debugging

## Getting Started with development 🚀

### What You'll Need

Required tools:

- [Bun](https://bun.sh) - A fast all-in-one JavaScript runtime & toolkit
- [Node.js](https://nodejs.org/) (v18 or higher) - JavaScript runtime environment
- [Git](https://git-scm.com/downloads) - For version control
- [Google Chrome](https://www.google.com/chrome/) - The browser we're building for

This extension uses:

- [TypeScript](https://www.typescriptlang.org/) - Type-safe JavaScript
- [React](https://react.dev/) - UI framework
- [Tailwind CSS](https://tailwindcss.com/) - Utility-first CSS framework
- [Webpack](https://webpack.js.org/) - Module bundler

#### Installing Node.js

1. Download Node.js from [nodejs.org](https://nodejs.org/)
2. Choose the LTS (Long Term Support) version
3. Run the installer
4. Verify installation:

   ```bash
   node --version
   npm --version
   ```

#### Installing Bun

Bun is required to run this project. Here's how to install it:

**Windows Users:**

1. First, install Windows Subsystem for Linux (WSL):

   ```powershell
   # Open PowerShell as Administrator and run:
   wsl --install
   ```

   After installation, restart your computer.

2. Install Bun through WSL:

   ```bash
   # Open WSL terminal and run:
   curl -fsSL https://bun.sh/install | bash
   ```

**macOS or Linux Users:**

```bash
# Open terminal and run:
curl -fsSL https://bun.sh/install | bash
```

To verify installation, run:

```bash
bun --version
```

### Setting Up Your Development Environment

1. Get the code:

   ```bash
   # Clone this repository to your computer
   git clone https://github.com/richards199999/Thinking-Claude.git

   # Go to the extension directory
   cd extensions/chrome

   # Install project dependencies
   bun install
   ```

### Development Commands

Here are the main commands you'll use during development:

```bash
# Build the extension for production
bun run build

# Start development mode with auto-reload
bun run start

# Watch for file changes
bun run watch

# Run tests
bun run test

# Fix code style and formatting
bun run fix
```

### Installing the Extension in Chrome

1. Open Chrome and type `chrome://extensions/` in the address bar
2. Turn on "Developer mode" using the switch in the top right corner
3. Click "Load unpacked" and select the `dist (visible after running bun run build)` folder from this project

## Project Organization 📁

```
chrome/
├── src/             # Your source code goes here
├── public/            # Built extension (created after running build)
│   ├── manifest.json # Extension configuration
│   ├── content.js   # Main extension script
│   └── icons/       # Extension icons
├── package.json     # Project configuration and scripts
└── CHANGELOG.md     # Version history and changes
```

## Development Workflow 🔄

### Code Quality Tools

We use several tools to maintain code quality:

- **Husky**: Automatically checks your code before commits
- **ESLint**: Finds and fixes JavaScript problems
- **Prettier**: Formats your code consistently

### Version Control & Releases

The project uses automated version bumping through CI:

- **Automatic Version Bumping**: When code is merged to main, the CI will:

  - Auto-increment the patch version (e.g., 1.0.0 -> 1.0.1)
  - Create a new release with the bumped version
  - Skip version bump for major versions (x.0.0)

- **Manual Version Control**:
  - Developers can manually set both versions in `package.json` and `manifest.json`
  - Major version changes (x.0.0) must be set manually
  - Manual versions will be respected by CI

> **Note**: If you need to manually set a version, update both `package.json` and `manifest.json` before merging to main.

### Continuous Integration

Our GitHub Actions setup automatically:

- Builds the extension
- Updates version numbers
- Creates new releases

## Need Help? 🤔

- Check the [CHANGELOG.md](./CHANGELOG.md) for recent updates
- Visit our [GitHub Issues](https://github.com/richards199999/Thinking-Claude/issues) for known problems or to report new ones
- Feel free to ask questions in our GitHub Discussions

Let your Claude able to think


# ⚠ Deprecated: Thinking Claude Chrome Extension (v0)

> **Important**: This version of the Chrome extension (`chrome_v0`) has been deprecated and is no longer being maintained. Please use our new version for continued support and improvements.

## Migration Notice 🔄

### Why are we deprecating this version?

We've completely rewritten the extension with:

- Modern architecture and tech stack
- Improved performance
- Better maintainability
- Enhanced developer experience

### How to Update?

Please switch to our new version (`chrome`):

1. Uninstall this version (`chrome_v0`) from Chrome
2. Visit our [Latest Releases](https://github.com/richards199999/Thinking-Claude/releases) or refer to the [README.md](https://github.com/richards199999/Thinking-Claude/tree/main/extensions/chrome/README.md) in `extensions/chrome`
3. Download and install the new version

For installation instructions and documentation, see:

- [New Extension Documentation](https://github.com/richards199999/Thinking-Claude/tree/main/extensions/chrome/README.md)
- [Changelog](https://github.com/richards199999/Thinking-Claude/tree/main/extensions/chrome/CHANGELOG.md)

## Support

- This version will remain available for historical reference
- No new features or bug fixes will be added
- For any issues, please use the new version
- Report problems with the new version in our [GitHub Issues](https://github.com/richards199999/Thinking-Claude/issues)

---

Thank you for using Thinking Claude! We're committed to providing the best possible experience, which is why we've moved to a new, improved version.

Let your Claude able to think


# Open Deep Research

An AI-powered research assistant that performs iterative, deep research on any topic by combining search engines, web scraping, and large language models.

The goal of this repo is to provide the simplest implementation of a deep research agent - e.g. an agent that can refine its research direction over time and deep dive into a topic. Goal is to keep the repo size at <500 LoC so it is easy to understand and build on top of.

If you like this project, please consider starring it and giving me a follow on [X/Twitter](https://x.com/dzhng). This project is sponsored by [Aomni](https://aomni.com).

## How It Works

```mermaid
flowchart TB
    subgraph Input
        Q[User Query]
        B[Breadth Parameter]
        D[Depth Parameter]
    end

    DR[Deep Research] -->
    SQ[SERP Queries] -->
    PR[Process Results]

    subgraph Results[Results]
        direction TB
        NL((Learnings))
        ND((Directions))
    end

    PR --> NL
    PR --> ND

    DP{depth > 0?}

    RD["Next Direction:
    - Prior Goals
    - New Questions
    - Learnings"]

    MR[Markdown Report]

    %% Main Flow
    Q & B & D --> DR

    %% Results to Decision
    NL & ND --> DP

    %% Circular Flow
    DP -->|Yes| RD
    RD -->|New Context| DR

    %% Final Output
    DP -->|No| MR

    %% Styling
    classDef input fill:#7bed9f,stroke:#2ed573,color:black
    classDef process fill:#70a1ff,stroke:#1e90ff,color:black
    classDef recursive fill:#ffa502,stroke:#ff7f50,color:black
    classDef output fill:#ff4757,stroke:#ff6b81,color:black
    classDef results fill:#a8e6cf,stroke:#3b7a57,color:black

    class Q,B,D input
    class DR,SQ,PR process
    class DP,RD recursive
    class MR output
    class NL,ND results
```

## Features

- **Iterative Research**: Performs deep research by iteratively generating search queries, processing results, and diving deeper based on findings
- **Intelligent Query Generation**: Uses LLMs to generate targeted search queries based on research goals and previous findings
- **Depth & Breadth Control**: Configurable parameters to control how wide (breadth) and deep (depth) the research goes
- **Smart Follow-up**: Generates follow-up questions to better understand research needs
- **Comprehensive Reports**: Produces detailed markdown reports with findings and sources
- **Concurrent Processing**: Handles multiple searches and result processing in parallel for efficiency

## Requirements

- Node.js environment
- API keys for:
  - Firecrawl API (for web search and content extraction)
  - OpenAI API (for o3 mini model)

## Setup

### Node.js

1. Clone the repository
2. Install dependencies:

```bash
npm install
```

3. Set up environment variables in a `.env.local` file:

```bash
FIRECRAWL_KEY="your_firecrawl_key"
# If you want to use your self-hosted Firecrawl, add the following below:
# FIRECRAWL_BASE_URL="http://localhost:3002"

OPENAI_KEY="your_openai_key"
```

To use local LLM, comment out `OPENAI_KEY` and instead uncomment `OPENAI_ENDPOINT` and `OPENAI_MODEL`:
- Set `OPENAI_ENDPOINT` to the address of your local server (eg."http://localhost:1234/v1")
- Set `OPENAI_MODEL` to the name of the model loaded in your local server.

### Docker

1. Clone the repository
2. Rename `.env.example` to `.env.local` and set your API keys

3. Run `npm install`

4. Run the Docker image:

```bash
docker compose up -d
```

5. Execute `npm run docker` in the docker service:
```bash
docker exec -it deep-research npm run docker
```

## Usage

Run the research assistant:

```bash
npm start
```

You'll be prompted to:

1. Enter your research query
2. Specify research breadth (recommended: 3-10, default: 4)
3. Specify research depth (recommended: 1-5, default: 2)
4. Answer follow-up questions to refine the research direction

The system will then:

1. Generate and execute search queries
2. Process and analyze search results
3. Recursively explore deeper based on findings
4. Generate a comprehensive markdown report

The final report will be saved as `output.md` in your working directory.

### Concurrency

If you have a paid version of Firecrawl or a local version, feel free to increase the `ConcurrencyLimit` in `deep-research.ts` so it runs a lot faster.

If you have a free version, you may sometimes run into rate limit errors, you can reduce the limit (but it will run a lot slower).

### Custom endpoints and models

There are 2 other optional env vars that lets you tweak the endpoint (for other OpenAI compatible APIs like OpenRouter or Gemini) as well as the model string.

```bash
OPENAI_ENDPOINT="custom_endpoint"
OPENAI_MODEL="custom_model"
```

## How It Works

1. **Initial Setup**

   - Takes user query and research parameters (breadth & depth)
   - Generates follow-up questions to understand research needs better

2. **Deep Research Process**

   - Generates multiple SERP queries based on research goals
   - Processes search results to extract key learnings
   - Generates follow-up research directions

3. **Recursive Exploration**

   - If depth > 0, takes new research directions and continues exploration
   - Each iteration builds on previous learnings
   - Maintains context of research goals and findings

4. **Report Generation**
   - Compiles all findings into a comprehensive markdown report
   - Includes all sources and references
   - Organizes information in a clear, readable format

## License

MIT License - feel free to use and modify as needed.

README.md

An AI-powered research assistant that performs iterative, deep research on any topic by combining search engines, web scraping, and large language models.  The goal of this repo is to provide the simplest implementation of a deep research agent - e.g. an agent that can refine its research direction overtime and deep dive into a topic.


# A Comprehensive Analysis of NVIDIA's RTX 5000 Series for Gaming Performance

This report provides an in-depth technical and comparative analysis of NVIDIA’s new RTX 5000 series GPUs, with a focus on pure gaming performance. It covers architectural innovations, benchmarking results, design optimizations, and market positioning relative to both previous RTX generations and competing products such as AMD’s RX 9000 series. The following sections detail the extensive research conducted, incorporating insights from rigorous benchmarks, innovative engineering strategies, and comparative evaluations.

---

## 1. Introduction

The RTX 5000 series marks a significant generational leap for NVIDIA in catering specifically to high-performance gaming. This new lineup targets enthusiasts and professionals alike, delivering improved frame rates, cutting-edge AI upscaling, and state-of-the-art ray tracing capabilities. As a follow-up to prior queries comparing the RTX 5000 series to its predecessors and to AMD's upcoming offerings, this report aggregates all recent findings to offer an exhaustive analysis of its performance benefits.

---

## 2. Architectural Innovations and Design Enhancements

### 2.1. New Blackwell Architecture

- **Key Features:**
  - Integration of 5th Generation Tensor Cores and 4th Generation RT Cores.
  - Adoption of GDDR7 memory (up to 32GB in flagship models), offering up to 1792 GB/sec bandwidth.
  - Enhanced AI driven features with DLSS 4's Multi Frame Generation technology that utilizes a novel transformer model and an integrated AI management processor (AMP based on RISC-V).

### 2.2. Process Node Evolution

- Although the physical node change from TSMC N4 to N4P only provides a ~5% improvement, this modest uplift is compensated with significant architectural tweaks such as:
  - Increased number of CUDA cores (up to 33% more in some instances compared to the RTX 4090).
  - Advanced power distribution management via a 30-phase VRM design in flagship models (e.g., the RTX 5090 Founders Edition).

### 2.3. PCB and Cooling Innovations

- **Compact Two-Slot Design:**
  - Despite increased power envelopes (e.g., RTX 5090’s 575W vs. RTX 4090’s 450W), the engineering team managed to design a dense PCB that maintains a 2-slot footprint.

- **Enhanced Thermal Management:**
  - Implementation of dual flow-through cooling systems with liquid metal and triple-walled gaskets resulted in peak temperatures stabilized around 72°C (with even the flagship RTX 5090 successfully operating under heavy 4K loads).
  - Advanced measures like vapor-chambers and premium phase-change thermal pads further ensure that thermal-efficiency is maintained even under high power draw conditions.

- **Acoustic Engineering:**
  - Despite the higher TDP and increased power consumption (e.g., idle power draw for the RTX 5090 is 46W compared to 28–29W for the RTX 4090), acoustic performance is optimized to around 32.5 dBA at 1 meter via targeted airflow and noise reduction strategies.

---

## 3. Gaming Performance Benchmarks

The primary focus being gaming performance, this section incorporates multiple performance metrics and independent benchmarks from both synthetic tests (such as Blender and 3DMark) and popular gaming titles like Resident Evil 4, Horizon Forbidden West, Cyberpunk 2077, and Final Fantasy XVI.

### 3.1. Relative Performance Gains Over Previous Generations

- **RTX 5090:**
  - Delivers roughly 30–35% higher performance than the RTX 4090 in pure 4K, non-ray tracing gaming.
  - Offers 20–50% improvements in average frame rates across diverse gaming titles.
  - Demonstrates a 32% improvement in ray tracing performance alongside up to a two-fold increase in performance in specific titles.
  - Trade-off: Elevated power draw (575W) necessitates scrutinizing efficiency and overall FPS-per-watt metrics.

- **RTX 5080 and RTX 5070-Ti:**
  - The RTX 5080 shows about a 15% performance uplift (both in rasterization and in ray tracing tasks) relative to the previous generation’s 4080-Super series.
  - The RTX 5070-Ti positions itself as a best-value proposition for gamers by delivering approximately 20% higher performance than the older 4070-Ti-Super at a lower price point ($749.99) while boasting 16GB VRAM, making it particularly effective for high-resolution gaming.

### 3.2. Technical Specifications and Numbers

Table below summarizes the key specifications and performance benchmarks for representative models in the series:

| Model           | CUDA Cores | Boost Clock (GHz) | TGP (W) | Memory Configuration & Bandwidth                 | Performance Gains vs. Predecessor       |
|-----------------|------------|-------------------|---------|--------------------------------------------------|-----------------------------------------|
| RTX 5090        | 21,760+    | Higher (e.g., ~2.62 GHz similar or above) | 575     | 32GB GDDR7, 512-bit, up to 1792 GB/sec           | ~30–35% (raster), 27–35% (RT), significant DLSS gains |
| RTX 5080        | 10,752     | 2.62              | 360     | High-bandwidth GDDR7                              | Roughly 15–20% higher FPS in 4K gaming    |
| RTX 5070-Ti     | 8,960      | 2.45              | 300     | 16GB VRAM, GDDR7                                 | ~20% gain over 4070-Ti-Super              |

These improvements are driven by higher core counts, enhanced architectural features, and tailored driver optimizations that have addressed frametime issues previously seen in titles like Alan Wake 2.

---

## 4. AI and Upscaling Technologies

### 4.1. DLSS 4 Multi Frame Generation

- **Revolutionizing Frame Rates:**
  - DLSS 4 leverages a transformer-based model combined with the inbuilt RISC-V based AMP to deliver enhanced multi-frame generation.
  - This technology can boost performance by up to 40% in demanding, ray-traced scenes and even multiply frame rates by as much as 8X compared to traditional rendering methods.

### 4.2. NVIDIA Reflex 2

- **Latency Reduction:**
  - NVIDIA Reflex 2 technology slashes input latency by up to 75%, ensuring a smoother and more responsive gaming experience, particularly in competitive gaming scenarios.

### 4.3. Integration with AI-Driven Content Creation

- While the primary focus here is gaming, it is important to note that these AI enhancements also accelerate creative workloads, making the RTX 5000 series a versatile choice for AI research and content production.

---

## 5. Power Efficiency and Thermal Performance Considerations

### 5.1. Power Consumption Trade-offs

- The series, particularly the RTX 5090, sees significant increases in power draw (e.g., idle and load differences such as 46W idle power compared to 29W for the RTX 4090). The increase in power is justified by the raw performance gains but does come with questions regarding overall efficiency, especially in FPS-per-watt metrics.

### 5.2. Thermal Efficiency Advances

- **Innovative Cooling Techniques:** As outlined earlier, advanced cooling methods are crucial for stable performance at high power loads. The full flow-through cooling system ensures that despite the high TDP (up to 575W for the RTX 5090), steady-state operational temperatures remain near 72–77°C.

- **Memory Thermal Characteristics:** Although the GPU core temperatures are well-managed, memory temperatures can occasionally peak up to 89–90°C under strenuous gaming loads, prompting further investigation into long-term memory reliability under prolonged usage conditions.

---

## 6. Comparative Analysis with Predecessor and Competitor Products

### 6.1. Comparisons with Previous RTX Series Models

- **RTX 5000 vs. RTX 4000 Series:**
  - The RTX 5000 series shows a marked performance uplift across the board. For instance, while the RTX 5090 pushes around 30–35% performance improvements, the RTX 5080 and 5070-Ti deliver gains of 15% and 20% over the 4080-Super and 4070-Ti-Super, respectively.
  - The driver optimizations and thermal management technologies in the RTX 5000 series have also resolved issues seen in earlier generations (such as inconsistencies in frametime performance in certain titles).

### 6.2. Competitive Dynamics with AMD’s RX 9000 Series

- **AMD’s Positioning:**
  - Although AMD is rumored to be withdrawing from the ultra-high-end market, the RX 9000 series, exemplified by the RX 9070XT (with 16GB of VRAM), shows competitive pressure. Leaked 3DMark numbers indicate performance figures close to the RTX 5070 series, emphasizing raw performance metrics in 4K gaming.
  - Differences in memory configuration (GDDR6 for AMD vs. GDDR7 for NVIDIA) and architectural paradigms (RDNA 4 vs. Blackwell) make efficiency and performance trade-offs a key battleground.

- **Strategic Considerations:**
  - NVIDIA’s aggressive product segmentation, with pricing ranging from about $549 for lower-end models (e.g., RTX 5060) to nearly $2,000 for flagship variants (RTX 5090 Founders Edition), contrasts with AMD’s mid-range focus. This segmentation not only influences immediate gaming performance metrics but also longer-term upgrade cycles and market dynamics.

---

## 7. Market Impact, Value Trade-offs, and Future Outlook

### 7.1. Pricing Dynamics and Consumer Sentiment

- **Premium Pricing Concerns:**
  - The RTX 5090 is priced around $1,999.99 compared to the RTX 4090 at $1,599.99. Although this represents a 25% higher price point, the performance boost (around 30–35%) may justify the extra cost for gamers demanding uncompromised 4K and ray-traced performance.

- **Value Proposition of the RTX 5070-Ti:**
  - At approximately $749.99 with 16GB VRAM, the RTX 5070-Ti emerges as a clear best-value option for high-resolution gaming. Its competitive pricing relative to its performance makes it attractive for gamers who balance performance with cost efficiency.

- **Consumer Debates:**
  - Forum discussions and expert reviews reveal a divided community, with some criticisms over aggressive segmentation and high flagship pricing, while others commend the tailored use cases such as AI-enhanced gaming and professional creative workflows.

### 7.2. Future Technological Projections and Speculative Trends

- **Improved Driver Optimizations:**
  - Continued refinement in driver updates (addressing issues such as frametime inconsistencies) can further enhance performance in real-world gaming scenarios.

- **Potential New Technologies:**
  - Future iterations might explore even more efficient power scaling and cooling optimizations, perhaps integrating improved liquid cooling or hybrid passive-active cooling mechanisms to further lower the thermal footprint.
  - Given the competitive dynamics, both NVIDIA and AMD may drive innovations around VRAM management and efficiency, which could significantly impact future pricing and segmentation strategies.

- **AI and Upscaling Evolution:**
  - DLSS and AI-based rendering technologies are likely to become even more integral to gaming performance enhancements, with potential upcoming improvements focusing on reducing latency further and increasing real-time fidelity.

---

## 8. Conclusion

The RTX 5000 series represents a robust and innovative leap in gaming GPU technology. Key takeaways include:

- **Substantial Performance Increases:** A clear generational improvement over previous RTX models with substantial enhancements in 4K gaming, ray tracing, and AI-driven rendering.

- **Innovative Architecture and Thermal Design:** The Blackwell architecture combined with advanced cooling solutions enables such high performance while mitigating thermal concerns typically associated with higher TDP values.

- **Competitive Market Positioning:** NVIDIA’s strategy of aggressive segmentation and comprehensive performance gains reinforces its position, even as AMD’s RX 9000 series introduces competitive pressure in the mid-range segment.

- **Trade-offs in Efficiency:** The significant improvements come at the cost of increased power consumption, raising considerations for both energy efficiency and operational heat management under sustained loads.

This comprehensive analysis, rooted in extensive benchmarking and technical evaluations, should serve as a detailed reference for experts evaluating the RTX 5000 series for high-performance gaming. Future developments in AI rendering and thermal management are expected to further refine these impressive performance metrics, while competitive dynamics will continue to push the envelope in GPU technology.

---

*Note: Some projections and speculations in this report are based on emerging trends and early benchmarking data. Continued monitoring of real-world performance and driver updates is recommended for an ongoing evaluation.*

# End of Report

## Sources

- https://www.tomshardware.com/reviews/gpu-hierarchy,4388.html
- https://linustechtips.com/topic/1596724-my-personally-recommended-gpu-from-rtx-5000-series/
- https://www.forbes.com/sites/moorinsights/2025/01/23/nvidia-rtx-5090-graphics-card-review---get-neural-or-get-left-behind/
- https://www.neogaf.com/threads/nvidia-official-geforce-rtx-50-vs-rtx-40-benchmarks-15-to-33-performance-uplift-without-dlss-multi-frame-generation.1679651/
- https://pcoutlet.com/parts/video-cards/rtx-5070-ti-vs-rtx-5080-which-gpu-reigns-supreme
- https://www.kitguru.net/components/graphic-cards/dominic-moass/nvidia-rtx-5080-review-efficiency-gains-but-a-performance-letdown/all/1/
- https://forums.pcgamer.com/threads/rtx-5000-series-review-discussion.147293/
- https://www.techradar.com/computing/gpu/nvidias-new-next-gen-gpu-benchmarks-cause-concern-among-pc-gamers-particularly-with-the-rtx-5080-but-dont-panic-yet
- https://www.vcsolutions.com/blog/nvidia-rtx-5000-series-performance-unveiled/
- https://gamersnexus.net/gpus/nvidia-geforce-rtx-5090-founders-edition-review-benchmarks-gaming-thermals-power
- https://www.tomshardware.com/pc-components/gpus/nvidia-geforce-rtx-5090-review
- https://www.nvidia.com/en-us/geforce/news/rtx-50-series-graphics-cards-gpu-laptop-announcements/
- https://pcoutlet.com/parts/video-cards/nvidia-rtx-5000-series
- https://press.asus.com/news/press-releases/asus-nvidia-geforce-rtx-50-series-graphics-cards/
- https://galaxy.ai/youtube-summarizer/the-challenges-facing-nvidias-rtx-5000-series-and-amds-rx-8000-cards-VHQkBdeXzT0
- https://www.xda-developers.com/nvidia-rtx-5000-not-what-you-think/
- https://hardwarehunt.co.uk/blogs/pc-building-maintenance/amd-vs-nvidia-the-battle-between-radeon-rx-9000-and-rtx-5000?srsltid=AfmBOorJ59FR_9WsA8ol-7k9g_jPvGbbYgFK1MzbvOwRS05HQO8JdjoZ
- https://hardforum.com/threads/2025-nvidia-versus-amd-ati-rematch-5000-versus-9000-series-edition.2038817/
- https://9meters.com/technology/graphics/nvidia-shows-off-geforce-rtx-5090-fe-pcb-30-phases-of-stable-575w-power
- https://www.technology.org/2025/01/20/nvidias-rtx-5090-a-technological-leap-beyond-the-rtx-4090/

report.md


[![Bolt Open Source Codebase](./public/social_preview_index.jpg)](https://bolt.new)

> Welcome to the **Bolt** open-source codebase! This repo contains a simple example app using the core components from bolt.new to help you get started building **AI-powered software development tools** powered by StackBlitz’s **WebContainer API**.

### Why Build with Bolt + WebContainer API

By building with the Bolt + WebContainer API you can create browser-based applications that let users **prompt, run, edit, and deploy** full-stack web apps directly in the browser, without the need for virtual machines. With WebContainer API, you can build apps that give AI direct access and full control over a **Node.js server**, **filesystem**, **package manager** and **dev terminal** inside your users browser tab. This powerful combination allows you to create a new class of development tools that support all major JavaScript libraries and Node packages right out of the box, all without remote environments or local installs.

### What’s the Difference Between Bolt (This Repo) and [Bolt.new](https://bolt.new)?

- **Bolt.new**: This is the **commercial product** from StackBlitz—a hosted, browser-based AI development tool that enables users to prompt, run, edit, and deploy full-stack web applications directly in the browser. Built on top of the [Bolt open-source repo](https://github.com/stackblitz/bolt.new) and powered by the StackBlitz **WebContainer API**.

- **Bolt (This Repo)**: This open-source repository provides the core components used to make **Bolt.new**. This repo contains the UI interface for Bolt as well as the server components, built using [Remix Run](https://remix.run/). By leveraging this repo and StackBlitz’s **WebContainer API**, you can create your own AI-powered development tools and full-stack applications that run entirely in the browser.

# Get Started Building with Bolt

Bolt combines the capabilities of AI with sandboxed development environments to create a collaborative experience where code can be developed by the assistant and the programmer together. Bolt combines [WebContainer API](https://webcontainers.io/api) with [Claude Sonnet 3.5](https://www.anthropic.com/news/claude-3-5-sonnet) using [Remix](https://remix.run/) and the [AI SDK](https://sdk.vercel.ai/).

### WebContainer API

Bolt uses [WebContainers](https://webcontainers.io/) to run generated code in the browser. WebContainers provide Bolt with a full-stack sandbox environment using [WebContainer API](https://webcontainers.io/api). WebContainers run full-stack applications directly in the browser without the cost and security concerns of cloud hosted AI agents. WebContainers are interactive and editable, and enables Bolt's AI to run code and understand any changes from the user.

The [WebContainer API](https://webcontainers.io) is free for personal and open source usage. If you're building an application for commercial usage, you can learn more about our [WebContainer API commercial usage pricing here](https://stackblitz.com/pricing#webcontainer-api).

### Remix App

Bolt is built with [Remix](https://remix.run/) and
deployed using [CloudFlare Pages](https://pages.cloudflare.com/) and
[CloudFlare Workers](https://workers.cloudflare.com/).

### AI SDK Integration

Bolt uses the [AI SDK](https://github.com/vercel/ai) to integrate with AI
models. At this time, Bolt supports using Anthropic's Claude Sonnet 3.5.
You can get an API key from the [Anthropic API Console](https://console.anthropic.com/) to use with Bolt.
Take a look at how [Bolt uses the AI SDK](https://github.com/stackblitz/bolt.new/tree/main/app/lib/.server/llm)

## Prerequisites

Before you begin, ensure you have the following installed:

- Node.js (v20.15.1)
- pnpm (v9.4.0)

## Setup

1. Clone the repository (if you haven't already):

```bash
git clone https://github.com/stackblitz/bolt.new.git
```

2. Install dependencies:

```bash
pnpm install
```

3. Create a `.env.local` file in the root directory and add your Anthropic API key:

```
ANTHROPIC_API_KEY=XXX
```

Optionally, you can set the debug level:

```
VITE_LOG_LEVEL=debug
```

**Important**: Never commit your `.env.local` file to version control. It's already included in .gitignore.

## Available Scripts

- `pnpm run dev`: Starts the development server.
- `pnpm run build`: Builds the project.
- `pnpm run start`: Runs the built application locally using Wrangler Pages. This script uses `bindings.sh` to set up necessary bindings so you don't have to duplicate environment variables.
- `pnpm run preview`: Builds the project and then starts it locally, useful for testing the production build. Note, HTTP streaming currently doesn't work as expected with `wrangler pages dev`.
- `pnpm test`: Runs the test suite using Vitest.
- `pnpm run typecheck`: Runs TypeScript type checking.
- `pnpm run typegen`: Generates TypeScript types using Wrangler.
- `pnpm run deploy`: Builds the project and deploys it to Cloudflare Pages.

## Development

To start the development server:

```bash
pnpm run dev
```

This will start the Remix Vite development server.

## Testing

Run the test suite with:

```bash
pnpm test
```

## Deployment

To deploy the application to Cloudflare Pages:

```bash
pnpm run deploy
```

Make sure you have the necessary permissions and Wrangler is correctly configured for your Cloudflare account.

CONTRIBUTING.md

Prompt, run, edit, and deploy full-stack web applications


[![Bolt.new: AI-Powered Full-Stack Web Development in the Browser](./public/social_preview_index.jpg)](https://bolt.new)

# Bolt.new: AI-Powered Full-Stack Web Development in the Browser

Bolt.new is an AI-powered web development agent that allows you to prompt, run, edit, and deploy full-stack applications directly from your browser—no local setup required. If you're here to build your own AI-powered web dev agent using the Bolt open source codebase, [click here to get started!](./CONTRIBUTING.md)

## What Makes Bolt.new Different

Claude, v0, etc are incredible- but you can't install packages, run backends or edit code. That’s where Bolt.new stands out:

- **Full-Stack in the Browser**: Bolt.new integrates cutting-edge AI models with an in-browser development environment powered by **StackBlitz’s WebContainers**. This allows you to:
  - Install and run npm tools and libraries (like Vite, Next.js, and more)
  - Run Node.js servers
  - Interact with third-party APIs
  - Deploy to production from chat
  - Share your work via a URL

- **AI with Environment Control**: Unlike traditional dev environments where the AI can only assist in code generation, Bolt.new gives AI models **complete control** over the entire  environment including the filesystem, node server, package manager, terminal, and browser console. This empowers AI agents to handle the entire app lifecycle—from creation to deployment.

Whether you’re an experienced developer, a PM or designer, Bolt.new allows you to build production-grade full-stack applications with ease.

For developers interested in building their own AI-powered development tools with WebContainers, check out the open-source Bolt codebase in this repo!

## Tips and Tricks

Here are some tips to get the most out of Bolt.new:

- **Be specific about your stack**: If you want to use specific frameworks or libraries (like Astro, Tailwind, ShadCN, or any other popular JavaScript framework), mention them in your initial prompt to ensure Bolt scaffolds the project accordingly.

- **Use the enhance prompt icon**: Before sending your prompt, try clicking the 'enhance' icon to have the AI model help you refine your prompt, then edit the results before submitting.

- **Scaffold the basics first, then add features**: Make sure the basic structure of your application is in place before diving into more advanced functionality. This helps Bolt understand the foundation of your project and ensure everything is wired up right before building out more advanced functionality.

- **Batch simple instructions**: Save time by combining simple instructions into one message. For example, you can ask Bolt to change the color scheme, add mobile responsiveness, and restart the dev server, all in one go saving you time and reducing API credit consumption significantly.

## FAQs

**Where do I sign up for a paid plan?**
Bolt.new is free to get started. If you need more AI tokens or want private projects, you can purchase a paid subscription in your [Bolt.new](https://bolt.new) settings, in the lower-left hand corner of the application.

**What happens if I hit the free usage limit?**
Once your free daily token limit is reached, AI interactions are paused until the next day or until you upgrade your plan.

**Is Bolt in beta?**
Yes, Bolt.new is in beta, and we are actively improving it based on feedback.

**How can I report Bolt.new issues?**
Check out the [Issues section](https://github.com/stackblitz/bolt.new/issues) to report an issue or request a new feature. Please use the search feature to check if someone else has already submitted the same issue/request.

**What frameworks/libraries currently work on Bolt?**
Bolt.new supports most popular JavaScript frameworks and libraries. If it runs on StackBlitz, it will run on Bolt.new as well.

**How can I add make sure my framework/project works well in bolt?**
We are excited to work with the JavaScript ecosystem to improve functionality in Bolt. Reach out to us via [hello@stackblitz.com](mailto:hello@stackblitz.com) to discuss how we can partner!

README.md


---
name: Feature request
about: Suggest an idea for this project
title: ''
labels: ''
assignees: ''
---

**Is your feature request related to a problem? Please describe:**

<!-- A clear and concise description of what the problem is. Ex. I'm always frustrated when [...] -->

**Describe the solution you'd like:**

<!-- A clear and concise description of what you want to happen. -->

**Describe alternatives you've considered:**

<!-- A clear and concise description of any alternative solutions or features you've considered. -->

**Additional context:**

<!-- Add any other context or screenshots about the feature request here. -->


# The Hugging Face Agents Course

If you like the course, **don't hesitate to ⭐ star this repository**. This helps us to **make the course more visible 🤗**.

## Content

The course is divided into 5 units. These will take you from **the basics of agents to a final assignment with a benchmark**.

Sign up here (it's free) 👉 https://bit.ly/hf-learn-agents

You can access the course here 👉 https://hf.co/learn/agents-course

| Unit | Topic                          | Description                                                                 |
|------|--------------------------------|-----------------------------------------------------------------------------|
| 0    | [Welcome to the Course](https://huggingface.co/learn/agents-course/en/unit0/introduction) | Welcome, guidelines, necessary tools, and course overview.                  |
| 1    | [Introduction to Agents](https://huggingface.co/learn/agents-course/en/unit1/introduction)       | Definition of agents, LLMs, model family tree, and special tokens.          |
| 1.5    | [(Bonus Unit 1) Fine-tuning an LLM for Function-calling](https://huggingface.co/learn/agents-course/bonus-unit1/introduction)       | Learn to fine-tune an LLM for Function-Calling |
| 2    | [2_frameworks](units/en/unit2/README.md)                     | Overview of smolagents, LangChain, LangGraph, and LlamaIndex.               |
| 3    | [3_use_cases](units/en/unit3/README.md)                      | SQL, code, retrieval, and on-device agents using various frameworks.        |
| 4    | [4_final_assignment_with_benchmark](units/en/unit4/README.md) | Automated evaluation of agents and leaderboard with student results.        |

## Prerequisites

- Basic knowledge of Python
- Basic knowledge of LLMs

## Contribution Guidelines

If you want to contribute to this course, you're welcome to do so. Feel free to open an issue or join the discussion in the [Discord](https://discord.gg/UrrTSsSyjb). For specific contributions, here are some guidelines:

### Small typo and grammar fixes

If you find a small typo or grammar mistake, please fix it yourself and submit a pull request. This is very helpful for students.

### New unit

If you want to add a new unit, **please create an issue in the repository, describe the unit, and why it should be added**. We will discuss it and if it's a good addition, we can collaborate on it.

### Work on existing units

We are actively working on the units and if you want to join us, we will need to find a place in the workflow. Here's an overview of where we are open to collaboration:

| Unit | Status        | Contributions                                                          |
|------|--------------|------------------------------------------------------------------------|
| 0    | ✅ Complete    | Bug fixes and improvements only                                        |
| 1    | ✅ Complete    | Bug fixes and improvements only                         |
| 2    | 🚧 In Progress | If you're a contributor to a framework, we're open to contributions and reviews |
| 3    | 🗓 Planned    | If you're experienced with agents, we're open to help with use cases |
| 4    | 🚧 In Progress | Work is underway, no need for help with integration                         |

If in doubt, join the discussion in the [Discord](https://discord.gg/UrrTSsSyjb).

## Citing the project

To cite this repository in publications:

```bibtex
@misc{agents-course,
  author = {Burtenshaw, Ben and Thomas, Joffrey and Simonini, Thomas},
  title = {The Hugging Face Agents Course},
  year = {2025},
  howpublished = {\url{https://github.com/huggingface/agents-course}},
  note = {GitHub repository},
}
```

README.md

This repository contains the Hugging Face Agents Course.


---
name: I have a bug with a hands-on
about: You have encountered a bug during one of the hands-on
title: "[HANDS-ON BUG]"
labels: hands-on-bug
assignees: ''

---

**Describe the bug**
A clear and concise description of what the bug is.

**To Reproduce**
Please provide any informations and a **link** to your hands-on so that we can investigate.

**Screenshots**
If applicable, add screenshots to help explain your problem.

**Additional context**
Add any other context about the problem here.


---
name: I have a question
about: You have a question about a section of the course
title: "[QUESTION]"
labels: question
assignees: ''

---

First, the **best way to get a response fast is to ask the community** in our Discord server: https://www.hf.co/join/discord

However, if you prefer you can ask here, please **be specific**.


---
name: I want to improve the course or write a new section
about: You found a typo, an error or you want to improve a part of the course or write
  a full section/unit
title: "[UPDATE]"
labels: documentation
assignees: ''

---

1. If you want to add a full section or a new unit, **please describe precisely what you want to add before starting to write it** so that we can review the idea, validate it or not, and guide you through the writing process.

2. If there's a typo, you can directly open a PR.


# Table of Contents

You can access Unit 1 on hf.co/learn 👉 here


# 目录

您可以在 hf.co/learn 上访问第 1 单元 👉 此处