Find all paths in a graph
I don't think memoization will be useful here. Any correct algorithm is going to be O(n!), nothing you do can reduce that fundamentally because you still have to output all the paths.
Trying to cache stuff you already output is just going to make the space-costs worse, it won't make the processing-time any better.
The advantages of using a generator are that the caller doesn't have to wait for the whole computation to finish before handling the early outputs, and that we never have to store the results of the whole computation at once. This is a good choice for the task at hand!
It doesn't affect the point in (1.) though.
You seem to have already found the textbook algorithm.
There are various things to make the code prettier, but you'd have to do some testing to see if they make it work better.

Types are nice. They do nothing at runtime, but they let MyPy check for many kinds of mistakes.
I don't like the redundancy of path and seen, and I don't like that you're mutating seen the way you are, but I suspect the way you've written it is actually the most efficient for larger graphs.
The expression path + [src] makes two calls to the list constructor, and it's happening inside the for loop. That can be improved!
Since you never mutate a value of path, it can be a tuple instead of a list.
The way you have it set up now, your adjacencies dict will always contain src, so you don't need to use get.



I'm ignoring your outer wrapper, and I've made no effort to test this:
from typing import Iterable, Mapping, MutableSet, Sequence, TypeVar
N = TypeVar('N')
def dfs(source: N,  # The current node
        destination: N,  # The destination node
        path: Sequence[N],  # The path taken to the current node
        seen: MutableSet[N],  # The nodes visited on the path
        graph: Mapping[N, Iterable[N]]  # The graph being explored, as an adjacency dict
) -&gt; Iterable[Sequence[N]]:
    new_path = (*path, source)
    if source == destination:
        yield new_path
    else:
        seen.add(source)
        for n in graph[source]:
            if n not in seen:
                yield from dfs(n, destination, new_path, seen, graph)
        seen.remove(source)