Is this the correct way of using Recursive functions?

Tab your code correctly.

The recursive GetDescendants looks correct, but I would suggest defining it differently for cleanliness.

It's bad to define functions inside of functions (it's not performant, and it's confusing), especially when it's not necessary. If we make descendants a parameter, then we don't need to make a new function, nor we do we need a separate functions for GetDescendants and recursiveGetChildren.

Let's not use pcall, either, since that's a crummy solution. In this case you should only be caring about physical things, you don't need to worry about errors -- just use workspace instead of game (which will be "more correct" anyway since things hidden in ReplicatedStorage or wherever won't trigger it for no apparent reason).

-- REQUIRES: model and descendants of model can have :GetChildren() called
-- on them.
-- PURPOSE: Given a model, returns a list of all of the descendants of that model.
-- [If result is specified, it will add the descendants of result to model.]
function descendants( model, result )
	result = result or {} -- No need to pass in result
	for _, child in pairs(model:GetChildren()) do
		table.insert(result, child) -- Much cleaner way to add to list
		descendants(child, result)
	end
	return result -- Return the accumulated children
end

There's no reason to define findInteract inside of a loop. Though findInteract also isn't used, so I'm not sure why you included it.

I would suggest instead making this function:

-- PURPOSE: Returns whether or not this part is an interaction site.
-- REQUIRES: part must be a ROBLOX object.
function isInteraction( part )
	return part:IsA("BasePart")
		and part:FindFirstChild("Interaction")
		and part.Interaction:IsA("StringValue")
end

Now we can easily filter the list of everything with just the interactable parts:

local interactions = {} -- List of all interaction sites.
local everything = descendants( workspace )
for _, object in pairs( everything ) do
	if isInteraction( object ) then
		table.insert( interactions, object )
	end
end

GetGui does absolutely nothing. It doesn't return anything, and has no side effects. Despite not having anything to do with its enclosed function, you have defined it inside of another function. Bad.

The remainder can be otherwise much simpler.

-- Define the GUI we give to players
local interactionGui = game.ReplicatedStorage.InteractionGui

-- REQUIRES: player is a Player, they have a Character (with torso) and PlayerGui.
-- PURPOSE: Shows or hides (by deleting/inserting) the InteractionGui
-- based on whether or not they are close to any interaction site (in `interactions`)
function update(player)
	-- We defined the table of "interactions" above
	local torso = player.Character.Torso
	local near = nil -- Near nothing.
	for _, interaction in pairs(interactions) do
		if (interaction.position - torso.Position).magnitude <= 3 then
			-- Within three studs of interaction's center
			near = interaction
		end
	end

	local playerGui = player.PlayerGui
	local hasGui = playerGui:FindFirstChild( interactionGui.Name )
	if near then
		-- I am near an interaction
		if not hasGui then
			interactionGui:Clone().Parent = playerGui
		end
	else
		-- I am NOT near ANY site
		if hasGui then
			hasGui:Destroy()
		end
	end
end

-- Update all players
function updateAll()
	for _, player in pairs(game.Players:GetPlayers()) do
		if player.Character
			and player.Character:FindFirstChild("Torso")
			and player:FindFirstChild("PlayerGui") then
			update(player)
		end
	end
end

while wait(0.1) do
	updateAll()
end

This is overall much simpler and cleaner.

Slow down. When writing code, think about what needs to be done. Describe in words a function that needs to be done, and figure out what things it might need to do that other functions could do.

Once you have that tiny description, write out the code.

Since all you're doing is deleting and inserting the interaction gui, it might make more sense to just show or hide it. That would mean there would be less to think about and keep track of.