x2
('x2' stands for 'yeah, i would like to know that too')

x2 + 1

x2 + 2

x2 + 3

x2 + 4

x2 + 5

Response to Issue #9: Function Calling and Structured Outputs

Thank you for your question and for the community’s interest in this feature! Below, I’ve addressed the current status and future plans for function calling and structured outputs in DeepSeek R1.

Current Status

• As of now, DeepSeek R1 does not natively support function calling or structured outputs.
• The model is primarily optimized for reasoning-heavy tasks (e.g., math, code, and STEM) and follows a conversational format.

Future Plans

• We recognize the importance of function calling and structured outputs for many use cases, such as API integrations, automation, and data extraction.
• We are actively exploring ways to add support for these features in future updates. This includes:
  • Extending the model’s capabilities to handle structured data formats (e.g., JSON, XML).
  • Adding support for function calling to enable seamless integration with external tools and APIs.

Timeline

• While we don’t have a specific release date yet, we aim to roll out these features in the next major update.
• We will keep the community updated on our progress through GitHub announcements and release notes.

Workarounds for Now

If you need structured outputs or function-like behavior in the meantime, here are some workarounds:

1. Post-Processing Outputs:

   • Use a script to parse the model’s responses into structured formats (e.g., JSON).
   • Example:

     import json
     
     response = model.generate("Extract the following data as JSON: ...")
     structured_data = json.loads(response)

2. Prompt Engineering:

   • Design prompts to guide the model to produce outputs in a specific format.
   • Example:

     Extract the following information and format it as JSON:
     - Name: ...
     - Age: ...
     - Location: ...
     

3. Custom Wrapper:

   • Build a custom wrapper around the model to simulate function calling behavior.
   • Example:

     def call_function(model, function_name, args):
         prompt = f"Call function {function_name} with args {args} and return the result."
         return model.generate(prompt)

Community Feedback

We appreciate the enthusiasm from the community (x2 + 5 and counting!). Your feedback is invaluable in shaping the future of DeepSeek R1. If you have specific use cases or feature requests related to function calling and structured outputs, please share them in this thread.

Next Steps

• We will prioritize this feature based on community demand and provide updates as development progresses.
• Stay tuned for announcements and feel free to contribute ideas or suggestions!

Thank you for your patience and support as we work to make DeepSeek R1 even better! Let us know if you have further questions or need additional assistance.

Thank you developers for explaining your plans to us. Don’t worry, if the application direction of R1 is not in the Agent field, developers can go in their own direction.
If the LLM has two directions of development: more like a thinker, more like a worker, I hope he will be more like a thinker.

Use R1 as the master brain for tool decision / plan, and rewrite the output in structure with another model.

I would really like the model to support structured output, such as JSON. For now, no matter how much I tell it to only output JSON it is not consistent. I don't mind the section I think that is useful and very easy to remove with some string handling, but it needs to adhere to JSON output if asked in its final response.

Also looking for this

Bump, definitely bump

When will R1 support agent?

response_format: { type: 'json_object' }

Thank you. I look forward to having a provider that allows my Microsoft Semantic Kernel powered application to use Deepseek as an alternative for auto function calling.

x2

https://github.com/justinlietz93/agent_tools

I built a suite of tools and a wrapper for deepseek reasoner to use, check it out

My application automates code generation using file operations via functional calls. Currently, integrating R1 requires significant refactoring due to the lack of function calling support, even though this feature is already standardized in most models (OpenAI, Anthropic, Mistral, etc.). To migrate from other models to R1, I must rewrite critical components of the application, which increases transition costs and error risks. Without function calling support, developers are forced to adopt less efficient workarounds or delay adopting R1, despite its exceptional code generation capabilities.

Accelerating the development of function calling for R1 will lower the entry barrier for communities relying on industry-standard approaches.

My application automates code generation using file operations via functional calls. Currently, integrating R1 requires significant refactoring due to the lack of function calling support, even though this feature is already standardized in most models (OpenAI, Anthropic, Mistral, etc.). To migrate from other models to R1, I must rewrite critical components of the application, which increases transition costs and error risks. Without function calling support, developers are forced to adopt less efficient workarounds or delay adopting R1, despite its exceptional code generation capabilities.

Accelerating the development of function calling for R1 will lower the entry barrier for communities relying on industry-standard approaches.

Can you please email me, feel free to look at my agent_tools repo, I have powerful tools for Deepseek R1 and I’m improving them daily. [email protected], I have more contact links on my github

go

Agree with the original feature request ( function calling and structured outputs standard features on a API now), without structured outputs, it's nearly impossible to achieve targeted data accuracy levels for many applications. When needing data accuracy of 99.999% on large volumes ( hundreds of thousands of records), structured outputs made a huge difference in the accuracy of my responses for unstructured ( document store) database queries using o1-mini.

Function calling, yes, I could do the workaround as suggested), but given the time and effort I already put into the development of the autonomous agent back end programming, I'd prefer not to go backwards and put in workarounds to use R1 when hopefully my existing code using function calling will be adequate when the R series of models and the DeepSeek API can in fact support function calling - hopefully the DeepSeek function calling and structured outputs performance will be just as good as on the OpenAI API using o1 and gpt-4o.

x2

We got function-calling to work with R1 using our framework BAML: https://www.boundaryml.com/blog/deepseek-r1-function-calling . We haven't had any issues making it spit out structured data.

It doesn't need tool-apis or whatnot, we just serialize types into the prompt in an efficient way, and parse the output using a custom JSON parser to handle missing quotes etc.

Let us know if you do. Here is our open-source repo: https://github.com/BoundaryML/baml

I'm also looking forward

We got function-calling to work with R1 using our framework BAML: https://www.boundaryml.com/blog/deepseek-r1-function-calling . We haven't had any issues making it spit out structured data.

It doesn't need tool-apis or whatnot, we just serialize types into the prompt in an efficient way, and parse the output using a custom JSON parser to handle missing quotes etc.

Let us know if you do. Here is our open-source repo: https://github.com/BoundaryML/baml

Awesome I’m going to take a look, because I’ve been building something for the same idea, to allow any LLM to use any tool

Looking forward deep seek with function calling

+1

In case this is helpful for others, looks like the Qwen-32B distillation https://huggingface.co/deepseek-ai/DeepSeek-R1-Distill-Qwen-32B/discussions/7 has support for function calling.

Asking for
"response_format": {'type': 'json_object' }
too

Thanks for the effort

One possible alternative to builtin function calling via JSON is to leverage DeepSeek-R1's strong coding capabilities and let the model generate code actions in Python. I experimented with this approach and found that it outperforms Claude 3.5 Sonnet on agentic tasks by a large margin (65.5% vs 53.1% on a GAIA validation subset). I used freeact as agent scaffold.

I've spent the past week testing DeepSeek R1 with Cline, Roo Coder and a number of other agentic coding tools using a combination of templates and prompting methods. While R1 is clearly a very capable model in general - in reality it's not practical to use (especially in production) due to it's lack of tool/function calling.

I believe what we need is a battle-tested template or fine tune from DeepSeek to enable reliable tool/function calling.