# DeepLearning.AI and Nexusflow's 59-minute function calling course: what an FDE should keep and what to skip

> The final project turns customer service transcripts into SQL and writes the results to a database. It is the closest the course gets to the data pipelines a Forward Deployed Engineer builds.

Original: https://fdetimes.net/en/books-courses/deeplearning-ai-function-calling-course-review/

The course's final lesson lasts only 9 minutes, but it comes closest to the data pipeline work an FDE does: take a pile of customer service transcripts, have an LLM generate SQL calls, then write the results to a database. The course ends in a data table, not a chatbot.

That is why DeepLearning.AI's "Function-calling and data extraction with LLMs" is worth an evening of your time. It also has gaps, and if you don't know about them in advance you will carry the wrong habits into client work.

## Who made the course, and what does it teach?

This is a DeepLearning.AI short course made with Nexusflow and launched in 2024. It is taught by Jiantao Jiao, co-founder and CEO of Nexusflow and assistant professor of EECS and Statistics at UC Berkeley, and Venkat Srinivasan, a founding engineer at Nexusflow. The course page was last updated on 27 August 2026.

The course page states its goal plainly: two skills, function calling and extracting structured data from free text. The videos add up to about 58-59 minutes. The 1 hour 19 minutes shown on the page today includes another 10 minutes of reading and a 10-minute graded quiz.

The main lessons are: what function calling is (9 minutes), function calling variations (12 minutes), connecting external tools (5 minutes), structured extraction (7 minutes), applications (10 minutes) and a conversation-processing project (9 minutes).

The course is rated Beginner and assumes some familiarity with LLMs and basic Python. It is currently free during the platform's beta; graded assignments and the certificate require a PRO plan.

## Idea one: the model only writes the call; you run it

The most useful thing to take from the function calling lessons is this: the model reads the descriptions of the functions you declare and returns a function name and arguments. Whether to make the call, how to make it and how to check the arguments is the job of the code you write.

**Key point:** The model only writes the function call; your code decides whether it runs.

For an FDE this is the most important safety boundary. When a client asks "can the agent delete data on its own?", the right answer lives in the execution layer you build, not in the prompt.

Beyond single calls, the course covers parallel and nested calls. Watch this part closely, because real requests rarely need just one call.

## Idea two: extraction is function calling in disguise

The structured extraction lesson is only 7 minutes long, so don't expect depth. One way of thinking is still worth keeping: to pull data out of text, you declare a "function" whose parameters are exactly the fields you need, then let the model "call" it.

Picture a transcript: a customer rings to complain that an order arrived three days late and asks for a refund. You declare a function `log_ticket` with parameters for the order ID, the issue type, the level of frustration and whether a refund was requested.

The model returns a call with the values filled in, and your code checks the data types and turns it into an `INSERT` statement. That is the backbone of the course project.

The step you should add yourself is measuring how accurate the extraction is. Say you run 200 transcripts and check 50 by hand: if the "refund requested" field is wrong 6 times, that field's accuracy is 88%. That number is what a client needs to see before letting the data flow into their systems.

## Idea three: an OpenAPI spec is the bridge to the client's systems

Part of the course uses an OpenAPI specification to build calls to a web service. On a client site this is a very practical shortcut. Their internal systems often already have a spec, and you can generate the function list from it instead of writing each one by hand.

Advice for applying it: don't hand the model the entire spec. Pick the few endpoints the workflow actually needs, rewrite their descriptions so the meaning is clear, and block write and delete endpoints in the execution layer.

## What to skip

The hands-on exercises use NexusRavenV2-13B, an open-source model fine-tuned from CodeLlama-13B that can run on your own machine. The model's Hugging Face page says it beats GPT-4 by 7% in function calling success rate on nested and composite calls.

That is a benchmark published by the vendor itself, on one specific kind of call, so don't use the figure to persuade clients.

So learn the concepts, but don't memorise this model's prompt syntax. In real work you will have to move everything to OpenAI- or Anthropic-style tool use. The most worthwhile exercise is to rewrite the project using the API your client actually uses.

## Who should take it, and in what order?

The course suits engineers who have called LLM APIs a few times but have never connected a model to a real system. If you already run tool use in production, watch only the project and the OpenAPI section.

A sensible order: watch "What is function calling" for the concept, then "variations", then jump straight to the project. After that, go back to the extraction and tool-connection lessons. The certificate is unnecessary. FDE hiring managers will trust a repo more.

On your CV, don't write "completed a function calling course". Write that you built a pipeline from transcripts to a database, how many fields it extracts and what accuracy it reached on a set you labelled yourself. When a job description mentions agents or LLM integration, this is exactly the kind of evidence interviewers want to dig into.

The course gives you about an hour of concepts. The rest, measuring accuracy and blocking dangerous calls, is work you have to do yourself, and it is precisely the part employers pay for.

**Try this week:**

- Watch 'What is function calling' (9 minutes), then 'Function calling variations' (12 minutes), then go straight to the project (9 minutes); only then return to the extraction and tool-connection lessons
- Redo the project with the tool-use API of the provider you or your client use, on 20 transcripts you write yourself
- Label each extracted field right or wrong by hand, compute the accuracy rate, and put that number in the project's README

## Sources

- [Function-calling and data extraction with LLMs - DeepLearning.AI](https://www.deeplearning.ai/courses/function-calling-and-data-extraction-with-llms)

- [New course with Nexusflow: Function-calling and Data Extraction with LLMs](https://info.deeplearning.ai/new-course-with-nexusflow-function-calling-and-data-extraction-with-llms)

- [function-calling-and-data-extraction-with-llms (course companion repo)](https://github.com/ksm26/function-calling-and-data-extraction-with-llms)

- [Function-calling and data extraction with LLMs - DeepLearning.AI](https://www.deeplearning.ai/short-courses/function-calling-and-data-extraction-with-llms/)

- [Nexusflow/NexusRaven-V2-13B · Hugging Face](https://huggingface.co/Nexusflow/NexusRaven-V2-13B)