How to Use DeepSeek API for Free: Hands-On Integration Guide

The DeepSeek series of language models, including R1 and V3, have emerged as versatile tools for developers tackling code generation, text analysis, and problem-solving tasks. With Fireworks.ai, a platform offering $1 in free credits, you can experiment with both models at minimal cost. The guide demonstrates methods to obtain free access to DeepSeek R1 and V3 while providing relative feature assessments and implementing AI applications through Python and Google Colab.

Why Fireworks.ai?

Fireworks.ai is a developer-first platform offering:

• Free Tier: $1 credit (enough for 1.1M tokens with R1 or 833K tokens with V3).
• Low-Cost Models: Affordable pricing for both R1 and V3.
• LangChain Integration: Simplify AI workflows with pre-built tools.
• Scalability: Deploy models from prototyping to production.

Step-by-Step Setup

Step 1: Sign Up for Fireworks.ai

• Visit Fireworks.ai and create an account.
• Generate an API Key under API Keys.

Step 2: Set Up Google Colab

• Open a new Colab notebook.
• Install required libraries:

!pip install -qU langchain-fireworks

• langchain-fireworks integrates Fireworks.ai with LangChain, a framework for building AI apps.
• The -qU flag quietly upgrades existing installations.

Step 3: Secure Your API Key

Store your API key in Colab's secrets vault:

• Click the key icon in the left sidebar.

• Add a secret named FIREWORKS_API_KEY and paste your key.

• Load the key into your environment:

from google.colab import userdata
import os
fireworks_api_key = userdata.get('FIREWORKS_API_KEY')
os.environ["FIREWORKS_API_KEY"] = fireworks_api_key

Explanation:

• userdata.get() fetches the secret without exposing it in your code.
• Storing the key in os.environ makes it accessible to the LangChain library.

Step 4: Using DeepSeek R1

• R1 is ideal for quick, straightforward tasks:

from langchain_fireworks import ChatFireworks
llm_r1 = ChatFireworks(
    model="accounts/fireworks/models/deepseek-r1",
    temperature=0.3,
    max_retries=2
)

• model: Unique identifier for DeepSeek R1 on Fireworks.
• temperature (0-1): Controls randomness. Lower = factual, Higher = creative.
• max_retries: Retries failed API calls (e.g., network issues).

Example: Code Debugging

response = llm_r1.invoke("Fix this Python code: print('Hello, World!')")
print(response.content)  

Output

# Output: "The code is correct. To add a newline, use print('Hello, World!', end='\n')."

Step 5: Using DeepSeek V3

V3 handles complex reasoning and detailed responses:

llm_v3 = ChatFireworks(
    model="accounts/fireworks/models/deepseek-v3",  # V3 model ID (confirm on Fireworks)
    temperature=0,  # Precise answers
    max_retries=2
)

Example: Mathematical Reasoning

query = "Solve for x: 2^(x+3) = 32. Explain step-by-step."
response = llm_v3.invoke(query)
print(response.content)

Output:

think>
Okay, so I need to solve the equation 2^(x+3) = 32. Hmm, let's see. I remember that when dealing with exponential equations, the goal is usually to get the variable out of the exponent. One common way to do that is by taking the logarithm of both sides, but maybe there's a simpler way here since both sides are powers of 2? Let me check.
First, let me recall that 32 is a power of 2. Let me think: 2^1 is 2, 2^2 is 4, 2^3 is 8, 2^4 is 16, and 2^5 is 32. Oh, right! So 32 is 2^5. That might make things easier because if I can express both sides of the equation with the same base, then I can set the exponents equal to each other. That's a property of exponents, right? If a^b = a^c, then b = c, as long as a isn't 0 or 1. Since 2 is the base here and it's definitely not 0 or 1, that should work.
So, rewriting the equation: 2^(x+3) = 2^5. Now that both sides have the same base, I can set the exponents equal. That gives me x + 3 = 5. Then, solving for x, I subtract 3 from both sides: x = 5 - 3, so x = 2. Let me check that to make sure I didn't make a mistake.
Plugging x = 2 back into the original equation: 2^(2 + 3) = 2^5 = 32. Yep, that's correct. So x = 2 is the solution. Wait, but just to be thorough, what if I approached this using logarithms instead? Let me try that method to confirm.
Starting with 2^(x+3) = 32. Taking the logarithm base 2 of both sides: log₂(2^(x+3)) = log₂(32). The left side simplifies because log base 2 of 2 to any exponent is just the exponent itself. So that becomes (x + 3) = log₂(32). But log₂(32) is 5, since 2^5 = 32. So again, x + 3 = 5, leading to x = 2. Same result. Good, that confirms it.
Alternatively, if I used natural logarithm or common logarithm, would that work too? Let's see. Using natural logarithm, take ln of both sides: ln(2^(x+3)) = ln(32). Using the logarithm power rule, that becomes (x + 3) * ln(2) = ln(32). Then, solving for x: x + 3 = ln(32)/ln(2). Calculating ln(32)/ln(2), since 32 is 2^5, ln(32) is ln(2^5) = 5*ln(2). So ln(32)/ln(2) = 5*ln(2)/ln(2) = 5. Therefore, x + 3 = 5, so x = 2. Same answer again. So regardless of the method, the solution is x = 2.
I guess the key takeaway here is that if both sides of the equation can be expressed with the same base, it's more straightforward to set the exponents equal. But if not, using logarithms is a reliable method. In this case, since 32 is a power of 2, the first method is simpler. If the equation had different bases that couldn't be easily converted, then logarithms would be the way to go.
Another thing to note is that exponential functions are one-to-one, which means that if two exponential expressions with the same base are equal, their exponents must be equal. That's why setting the exponents equal works here. It's a fundamental property that's really useful for solving these types of equations.
Let me also consider if there are any other possible solutions. Since 2^x is a strictly increasing function, it will only cross any horizontal line once, so there's only one solution. Therefore, x = 2 is the only answer. There's no chance of another solution popping up, unlike in some quadratic or higher-degree equations where multiple solutions might exist.
Just to recap the steps clearly:
1. Recognize that 32 is a power of 2 (2^5).
2. Rewrite the original equation 2^(x+3) = 32 as 2^(x+3) = 2^5.
3. Since the bases are equal, set the exponents equal: x + 3 = 5.
4. Solve for x: x = 5 - 3 = 2.
5. Verify by plugging x = 2 back into the original equation to confirm it holds true.
This problem was a good example of how recognizing common powers can simplify solving exponential equations. If the equation had been something like 3^(x+1) = 27, the same approach would apply since 27 is 3^3. It's all about expressing both sides with the same base whenever possible.
Alternatively, if the equation was 2^(x+3) = 30, which isn't a power of 2, then logarithms would be necessary. In that case, you'd take log base 2 of both sides (or natural log) and solve for x using the logarithm properties. But in this problem, since 32 is a known power of 2, the process is much more straightforward.
I think that's about it. The key steps are recognizing the common base, rewriting the equation, equating the exponents, solving for x, and verifying the solution. This method ensures accuracy and avoids unnecessary complex calculations. It's always good to check the solution by substituting back into the original equation, just to be sure there were no algebraic mistakes made along the way.
</think>
To solve the equation \(2^{x+3} = 32\), follow these steps:
1. **Express 32 as a power of 2**:  
   Recognize that \(32 = 2^5\). This allows both sides of the equation to have the same base.
2. **Rewrite the equation**:  
   Substitute \(32\) with \(2^5\):  
   \[
   2^{x+3} = 2^5
   \]
3. **Set the exponents equal**:  
   Since the bases are identical, the exponents must be equal:  
   \[
   x + 3 = 5
   \]
4. **Solve for \(x\)**:  
   Subtract 3 from both sides:  
   \[
   x = 5 - 3 \quad \Rightarrow \quad x = 2
   \]
5. **Verify the solution**:  
   Substitute \(x = 2\) back into the original equation:  
   \[
   2^{2+3} = 2^5 = 32
   \]  
   The equation holds true, confirming the solution.
**Final Answer:**  
\(\boxed{2}\)

Step 6: Advanced Use Cases

Case 1: Prompt Templating with LangChain

from langchain.prompts import PromptTemplate
template = """
You are a senior developer. Explain the bug in this code and fix it:
Code: {code}
"""
prompt = PromptTemplate(
    template=template,
    input_variables=["code"]
)
# Format the prompt
code_snippet = "def add(a, b): return a - b"
_input = prompt.format(code=code_snippet)
# Generate response
response = llm_r1.invoke(_input)
print(response.content)

Output:

<think>
Okay, let's take a look at this code. The function is supposed to be called 'add', which immediately makes me think it's meant to add two numbers. But when I look at the return statement, it says 'a - b'. Oh, right, that's subtraction instead of addition. So the bug here is a simple typo where the operator is wrong. The function is named add, but it's performing subtraction. The fix should be changing the '-' to a '+'. Let me double-check. If someone calls add(2,3), it should return 5, but with the current code, it returns -1. Yep, definitely the operator is the issue. So the corrected code should be 'return a + b'. That's straightforward. No other issues in the code, just the wrong operator used.
</think>
The bug in the code is a logical error where the function `add` incorrectly subtracts `b` from `a` instead of adding them. This happens because the `-` operator is used instead of `+`.
**Step-by-step explanation:**
1. **Function Purpose:** The function is named `add`, indicating it should return the sum of `a` and `b`.
2. **Current Behavior:** The code uses `a - b`, which subtracts the values instead of adding them.
3. **Fix:** Replace the subtraction operator (`-`) with the addition operator (`+`).
**Corrected code:**
```python
def add(a, b):
    return a + b
```

Case 2: Comparative Analysis (R1 vs. V3)

Test both models on the same task:

query = "Explain recursion in programming."
# Using R1
response_r1 = llm_r1.invoke(query)
# Using V3
response_v3 = llm_v3.invoke(query)
print("=== R1 Response ===")
print(response_r1.content)
print("\n=== V3 Response ===")
print(response_v3.content)

Output for DeepSeek R1

=== R1 Response ===
<think>
Okay, so I need to explain recursion in programming. Let me start by recalling what I know. Recursion is when a function calls itself, right? But how does that actually work? I remember that there's a base case and a recursive case. The base case is when the function stops calling itself, preventing infinite loops. The recursive case is where the function calls itself with a modified parameter. 
Wait, maybe I should think of an example. Like calculating factorial numbers. The factorial of n is n multiplied by the factorial of n-1, and the base case is when n is 0 or 1, returning 1. So factorial(5) is 5 * factorial(4), which is 5 * 4 * factorial(3), and so on until it reaches factorial(1) which returns 1. That makes sense.
But how does the program keep track of all those function calls? Oh right, the call stack. Each recursive call adds a frame to the stack, and when the base case is reached, it starts unwinding the stack, multiplying the results as it goes back up. But if the recursion is too deep, you can get a stack overflow error. So you have to make sure the base case is reachable.
Another example could be the Fibonacci sequence. Fib(n) = Fib(n-1) + Fib(n-2), with base cases Fib(0) = 0 and Fib(1) = 1. But that's less efficient than an iterative approach because it recalculates the same values multiple times. Maybe that's why memoization is used in recursion sometimes to optimize.
Wait, but recursion can make code cleaner for problems that are naturally recursive, like tree traversals or divide and conquer algorithms. For example, in a binary search tree, searching can be done recursively by checking the current node and then recursively searching the left or right subtree.
I should also mention the potential downsides. Each recursive call adds a layer to the stack, so for very large inputs, it might not be the best approach. Some languages optimize for tail recursion, where the recursive call is the last operation, allowing the compiler to reuse the current stack frame. But not all languages support that.
So putting it all together, recursion is a technique where a function solves a problem by calling itself on smaller subproblems until it reaches a base case. It's useful for problems that can be broken down into similar subproblems, but you have to be cautious about stack depth and efficiency.
</think>
Recursion in programming is a technique where a **function calls itself** to solve a problem by breaking it into smaller, similar subproblems. Here's a structured explanation:
### Key Components of Recursion:
1. **Base Case**  
   - The condition that stops the recursion.  
   - Prevents infinite loops by returning a result directly without further calls.  
   - Example: For factorial, `factorial(0) = 1` or `factorial(1) = 1`.
2. **Recursive Case**  
   - The part where the function calls itself with a modified argument, moving toward the base case.  
   - Example: `factorial(n) = n * factorial(n - 1)`.
### How It Works:
- Each recursive call is added to the **call stack**, which stores pending function calls.  
- When the base case is reached, the stack "unwinds," combining results from the deepest call backward.  
- Example for `factorial(3)`:  
  ```
  factorial(3) → 3 * factorial(2)  
  factorial(2) → 2 * factorial(1)  
  factorial(1) → 1 (base case)  
  Final result: 3 * 2 * 1 = 6
  ```
### Use Cases:
- **Naturally recursive problems**:  
  - Tree/graph traversals (e.g., directory structures).  
  - Divide-and-conquer algorithms (e.g., merge sort, quicksort).  
  - Mathematical sequences (e.g., Fibonacci, factorials).
### Pros and Cons:
- **Advantages**:  
  - Simplifies code for problems with self-similar subproblems.  
  - Often mirrors mathematical definitions (e.g., Fibonacci).  
- **Drawbacks**:  
  - Risk of **stack overflow** for deep recursion (if no base case or large inputs).  
  - Can be less efficient than iteration due to repeated calls (e.g., Fibonacci without memoization).  
### Optimization Techniques:
- **Tail Recursion**:  
  - The recursive call is the last operation in the function.  
  - Some languages (e.g., Haskell, Scala) optimize this to reuse the stack frame.  
- **Memoization**:  
  - Cache results of expensive calls (e.g., storing Fibonacci results to avoid redundant calculations).
### Example Code (Factorial in Python):
```python
def factorial(n):
    if n == 0:  # Base case
        return 1
    else:       # Recursive case
        return n * factorial(n - 1)
```
### When to Use Recursion:
- When the problem can be divided into identical subproblems.  
- When readability and simplicity are prioritized over performance (for small inputs).  
- For recursive data structures (e.g., trees, linked lists).
### Final Note:
Recursion is a powerful tool but requires careful handling of the base case and stack usage. Always test for edge cases to avoid infinite loops!

Output for DeepSeek V3

=== V3 Response ===
Recursion in programming is a technique where a function calls itself in order to solve a problem. The idea is to break down a complex problem into smaller, more manageable sub-problems that are easier to solve. Each recursive call works on a smaller instance of the original problem, and the process continues until a base case is reached, which is a condition that stops the recursion.
### Key Components of Recursion:
1. **Base Case**: 
   - This is the condition under which the recursion stops. Without a base case, the function would call itself indefinitely, leading to a stack overflow or infinite loop.
   - Example: In a factorial function, the base case might be when the input is 0 or 1, since the factorial of 0 or 1 is 1.
2. **Recursive Case**:
   - This is where the function calls itself with a modified argument, moving closer to the base case.
   - Example: In a factorial function, the recursive case might involve multiplying the current number by the factorial of the number minus one.
### Example: Factorial Function
The factorial of a non-negative integer `n` (denoted as `n!`) is the product of all positive integers less than or equal to `n`. The factorial function can be defined recursively as follows:
```python
def factorial(n):
    # Base case: factorial of 0 or 1 is 1
    if n == 0 or n == 1:
        return 1
    # Recursive case: n! = n * (n-1)!
    else:
        return n * factorial(n - 1)
```
### How It Works:
- If `n` is 0 or 1, the function returns 1 (base case).
- Otherwise, the function calls itself with `n-1` and multiplies the result by `n` (recursive case).
### Example Execution:
Let's compute `factorial(3)`:
1. `factorial(3)` calls `factorial(2)`
2. `factorial(2)` calls `factorial(1)`
3. `factorial(1)` returns 1 (base case)
4. `factorial(2)` returns `2 * 1 = 2`
5. `factorial(3)` returns `3 * 2 = 6`
So, `factorial(3)` returns `6`.
### Advantages of Recursion:
- **Simplicity**: Recursive solutions can be more intuitive and easier to write for problems that have a natural recursive structure, such as tree traversals or divide-and-conquer algorithms.
- **Readability**: Recursive code can be more readable and concise, especially for problems that can be naturally divided into similar sub-problems.
### Disadvantages of Recursion:
- **Performance**: Recursive functions can be less efficient than iterative solutions due to the overhead of multiple function calls and the risk of stack overflow for deep recursion.
- **Memory Usage**: Each recursive call consumes stack space, which can lead to high memory usage for deep recursion.
### Tail Recursion:
Tail recursion is a special case of recursion where the recursive call is the last operation in the function. Some programming languages and compilers optimize tail-recursive functions to use constant stack space, effectively converting them into iterative loops. This can mitigate some of the performance and memory issues associated with recursion.
### Example of Tail Recursion:
```python
def factorial_tail_recursive(n, accumulator=1):
    if n == 0 or n == 1:
        return accumulator
    else:
        return factorial_tail_recursive(n - 1, n * accumulator)
```
In this version, the recursive call is the last operation, and the result is accumulated in the `accumulator` parameter.
### Conclusion:
Recursion is a powerful tool in programming, especially for problems that can be broken down into smaller, similar sub-problems. However, it's important to carefully design recursive functions to ensure they have a proper base case and to be aware of the potential performance and memory implications.

Using DeepSeek Models

Model Comparison

Step 8: Troubleshooting

• Model Not Found: Verify the model ID in the Fireworks Model Dashboard.
• Rate Limits: Fireworks allows 60 requests/minute. Add delays with time.sleep(1) if needed.
• Key Errors: Ensure secrets are named FIREWORKS_API_KEY in Colab.

Conclusion

With DeepSeek R1 and V3 on Fireworks.ai, you can build AI-powered tools for free whether you're debugging code, solving math problems, or generating content. The $1 credit offers ample room for experimentation, and the LangChain integration simplifies development.

Next Steps:

• Explore the Fireworks Documentation.
• Experiment with different temperature settings.
• Monitor usage in the Fireworks Dashboard.

Start coding with this Google Colab Template and unleash the power of AI today!

FAQ

Q: Can I use both models in the same project?

A: Yes! You can initialize R1 and V3 separately and route tasks based on complexity.

Q: How do I check my remaining credits?

A: Visit the Fireworks Usage Dashboard to monitor your available credits.

Q: What happens when I run out of free credits?

A: You can purchase additional credits through Fireworks.ai's pricing plans.

Q: Are these models suitable for commercial use?

A: Review Fireworks.ai's Terms of Service for licensing details regarding commercial applications.

Q: Can I fine-tune DeepSeek models on my data?

A: Fireworks.ai does not currently offer custom fine-tuning for DeepSeek models, but you can use prompt engineering to tailor outputs.