Using generic types for a custom mapper

Improving List<Guid> FilterOnContent<T>

You should use if/else structure when you need only a single condition to be triggered instead of multiple if's as the compiler will have to go over all of them, but that's not necessary because let's say typeof(T) == typeof(Restaurant) do you want to check typeof(T) == typeof(AlgorithmRestaurant) and the rest of your conditions? There is no point the type argument cant be 2 types at the same time.

var rated = (IEnumerable<AlgorithmRestaurant>)ratedItems;
var toFilter = (IEnumerable<AlgorithmRestaurant>)itemsToFilter;

Those helper variables seem pointless to me they just add 2 extra lines in each if branch.

The .ToList() also adds a few extra characters, while you can just call it once at the return statement.

You currently have only if statements so you cant guarantee for the compiler that there will always be exactly one condition that will be met, which means you need to allocate some extra memory at initialization:

var ratedRcis = new List<RecommenderContentItem>();

But with multiple else if's and a one else for the exception you wont need to do that.

The empty .Any() overload is O(1) operation but with else at the end you wont even need to do that.

With all of that in mind you can make your method look like this:

public static List<Guid> FilterOnContent<T>(List<T> ratedItems, List<T> itemsToFilter)
{
    RciConverter cnv = new RciConverter();

    IEnumerable<RecommenderContentItem> ratedRcis;
    IEnumerable<RecommenderContentItem> toFilterRcis;
    if (typeof(T) == typeof(Restaurant))
    {
        ratedRcis = cnv.ConvertMany((IEnumerable<Restaurant>) ratedItems);
        toFilterRcis = cnv.ConvertMany((IEnumerable<Restaurant>) itemsToFilter);
    }
    else if (typeof(T) == typeof(AlgorithmRestaurant))
    {
        ratedRcis = cnv.ConvertMany((IEnumerable<AlgorithmRestaurant>) ratedItems);
        toFilterRcis = cnv.ConvertMany((IEnumerable<AlgorithmRestaurant>) itemsToFilter);
    }
    else if (typeof(T) == typeof(Dish))
    {
        ratedRcis = cnv.ConvertMany((IEnumerable<Dish>) ratedItems);
        toFilterRcis = cnv.ConvertMany((IEnumerable<Dish>) itemsToFilter);
    }
    else
    {
        throw new TypeArgumentException("Invalid type."); //Custom exception written by Jon Skeet.
    }
    return ContentBasedFilter.Filter(ratedRcis.ToList(), toFilterRcis.ToList()).Select(rci => rci.Id).ToList();
}

In fact there isn't really a pretty way to shorten that, not much conversion is available to generics and since you need to know the type of casting at compile time you cant go fancy-mancy.

Shortening your mapping methods

Why would you write the same code in your ConvertMany when you already have it in the same method for a single instance Convert?

public IEnumerable<RecommenderContentItem> ConvertMany(IEnumerable<AlgorithmRestaurant> sourceObjects)
{
    return sourceObjects.Select(rest => new RecommenderContentItem
    {
        Id = rest.RestaurantId,
        AverageRating = rest.AverageRating,
        Tags = rest.Tags.ToList()
    });
}

public RecommenderContentItem Convert(AlgorithmRestaurant sourceObject)
{
    return new RecommenderContentItem
    {
        Id = sourceObject.RestaurantId,
        AverageRating = sourceObject.AverageRating,
        Tags = sourceObject.Tags.ToList()
    };
}

It doesn't makes sense you can just do:

public IEnumerable<RecommenderContentItem> ConvertMany(IEnumerable<AlgorithmRestaurant> sourceObjects)
{
    return sourceObjects.Select(rest => Convert(rest));
}

And even shorter with a method group:

public IEnumerable<RecommenderContentItem> ConvertMany(IEnumerable<AlgorithmRestaurant> sourceObjects)
{
    return sourceObjects.Select(Convert);
}

You can apply the same to all of your other ConvertMany methods.

Lastly I'm not sure why do you need everything to be in a List<T> if you don't have a really good reason to use them, you shouldn't call .ToList() everywhere if you data is huge enumerating it again would surely cause a bottleneck there.

public RecommenderContentItem Convert(AlgorithmRestaurant sourceObject)
{
  return new RecommenderContentItem
  {
      Id = sourceObject.RestaurantId,
      AverageRating = sourceObject.AverageRating,
      Tags = sourceObject.Tags.ToList()
  };
}

public RecommenderContentItem Convert(Dish sourceObject)
{
  return new RecommenderContentItem
  {
      Id = sourceObject.Id,
      AverageRating = sourceObject.AverageRating,
      Tags = sourceObject.Tags.ToList()
  };
}

public RecommenderContentItem Convert(Restaurant sourceObject)
{
  return new RecommenderContentItem
  {
      Id = sourceObject.Id,
      AverageRating = sourceObject.AverageRating,
      Tags = sourceObject.Tags.ToList()
  };
}

Look at these three methods. What do you see? They are virtually identical. In fact you don't need them at all because all types that you convert to RecommenderContentItem have the same three properties. All you need is just this interface that all three classes implement. Alternatively you can make the RecommenderContentItem an abstract class and the base class for the other types.

public interface IRecommenderContentItem
{
    Guid Id { get; set; }
    List<Tag> Tags { get; set; }
    double AverageRating { get; set; }
}

Then you can remove the most part of the FilterOnContent method and constrain T to be of that interface type:

public static List<Guid> FilterOnContent<T>(List<T> ratedItems, List<T> itemsToFilter) 
    where T : IRecommenderContentItem
{   
    if (!ratedItems.Any() || !itemsToFilter.Any())  throw new ArgumentException("Invalid type."); 

    return ContentBasedFilter.Filter(ratedRcis, toFilterRcis).Select(rci => rci.Id).ToList();
}

The ContentBasedFilter.Filter will need to be adjusted too but you didn't include it so I cannot say anything about it.