anchor.diff:      Timeout = proplists:get_value(timeout, Opts, default_timeout(get_index_timeout)),
       CallTimeout = proplists:get_value(call_timeout, Opts, default_timeout(get_index_call_timeout)),
       ReturnTerms = proplists:get_value(return_terms, Opts),
  +    MaxResults = proplists:get_value(max_results, Opts),
  +    Stream = proplists:get_value(stream, Opts, false),
  +
       Req = #rpbindexreq{bucket=Bucket, index=Index, qtype=range,
                          range_min=encode_2i(StartKey),
                          range_max=encode_2i(EndKey),
  -                       return_terms=ReturnTerms},
  -    gen_server:call(Pid, {req, Req, Timeout}, CallTimeout).
  +                       return_terms=ReturnTerms,
  +                       max_results=MaxResults,
  +                       stream=Stream},
  +    Call = case Stream of
  +               true ->
  +                   ReqId = mk_reqid(),
  +                   {req, Req, Timeout, {ReqId, self()}};
  +               false ->
  +                   {req, Req, Timeout}
  +           end,
  +    gen_server:call(Pid, Call, CallTimeout).
   
   encode_2i(Value) when is_integer(Value) ->
       list_to_binary(integer_to_list(Value));
  
positive.code: 
  process_response(#request{msg = #rpbindexreq{}}, rpbindexresp, State) ->
      {reply, {ok, []}, State};
  process_response(#request{msg = #rpbindexreq{return_terms=true}}, #rpbindexresp{results=Results}, State) ->
      {reply, {ok, Results}, State};
  process_response(#request{msg = #rpbindexreq{}}, #rpbindexresp{keys=Keys}, State) ->
  
negative.code:     {reply, {ok, Key}, State};
  process_response(#request{msg = #rpbputreq{bucket = Bucket, key = Key}},
                   #rpbputresp{content = RpbContents, vclock = Vclock,
                               key = NewKey}, State) ->
      Contents = riak_pb_kv_codec:decode_contents(RpbContents),
      ReturnKey = case NewKey of
                      undefined -> Key;
  