Every Symbol in Python Function Exists for a Reason.
def func(a, /, b, *args, c=10, **kwargs):
...
Every symbol in this function signature solves a real API design problem that appears in production systems.
Most developers don't know why they exist, how Python actually binds args internally, and when they should be used in Prod APIs.

Phase 1:
When a function is called, Python performs a process called argument binding.
This argument binding (mapping process) gets more complex when we introduce:
positional-only parameters
standard parameters
variadic positional parameters (args)
keyword-only parameters
variadic keyword parameters (*kwargs)

Decisions that it makes while binding:
which value belongs to which parameters?
which parameters are required?
which values go into tuples?
which values go into dictionaries?
whether the call is valid at all?

The four major parameter types:
Positional-only Parameters ( / )
Here the slash means: every param before this symbol can only be supplied positionally.
for example :
`def build_rag_pipeline(
index_path,
/,
):
pass

valid

build_rag_pipeline("/data/chroma")

invalid

build_rag_pipeline(index_path="/data/chroma")

output it will throw is :

TypeError:

get some positional-only arguments passed as keyword arguments

here we don't need labels to pass an arg.. python only expects values in a specific order.`

but why this parameter?
because this solves a versioning problem
def connect(host):
people write like :
connect(host="db.comapny.com")
later we might want to rename the field host to endpoint… this change will break every calls made.
However if we write something like:
def connect(host, /):
this will allow us to call using:
connect("db.company.com")
now we can safely change from host to endpoint and everything will work without breaking any code.
Many built-in functions use positional-only params:
len(obj), abs(x), pow(x,y) etc
Standard Parameters
this paremeter can be passed positionally as well as with keywords too.
example :
def func(name):
so this function can be called by:
func("Mukund")
and func(name="Mukund")
Variadic Positional Parameters (*args)
def func(*args):
print(args)

we can call it like

func(1,2,3,4)

output

(1,2,3,4)

Python automatically packs extra positional args into a tuple.

Keyword-Only Parameters ()
example:
def search(, top_k):
...

valid:

search(top_k=10)

invalid

search(10)
This will solve the readability problem.
Variadic Keyword Parameters (kwargs)
def func(kwargs):
print(kwargs)

so here we can call like

func(
timeout=20,
retry=3,
cache=True
)

it will produce:

{
"timeout":30,
"retry": 3,
"cache": True
}

python collects all keywords args into a dictionary

How FastAPI and Pydantic Change the Picture
The problem with kwargs is that it doesn't validate the input of function calls.
def endpoint(kwargs):
...

this code doesn't provide any schema, any contract, any validation

instead we can use pydantic

from pydantic import BaseModel
class PipelineConfig(BaseModel):
model_name: str
top_k: int
threshold: float
Now FastAPI gets automatic validation, generated OpenAPI docs, Swagger UI, static typing, IDE support, and API contracts.