> ## Documentation Index
> Fetch the complete documentation index at: https://docs.freeplay.ai/llms.txt
> Use this file to discover all available pages before exploring further.

# Streaming Responses

> Handle streaming LLM responses while recording completions to Freeplay for observability.

### Run a single prompt and stream the result

Executes a single prompt using specified variables, with a streaming response.

## Examples

<CodeGroup>
  ```python python theme={null}
  import os

  from freeplay import Freeplay
  from freeplay.provider_config import ProviderConfig, OpenAIConfig

  FREEPLAY_API_KEY = os.environ["FREEPLAY_API_KEY"]
  OPENAI_API_KEY = os.environ["OPENAI_API_KEY"]
  FREEPLAY_CUSTOMER_NAME = os.environ["FREEPLAY_CUSTOMER_NAME"]
  FREEPLAY_PROJECT_ID = os.environ["FREEPLAY_PROJECT_ID"]

  fp_client = Freeplay(
      provider_config=ProviderConfig(openai=OpenAIConfig(OPENAI_API_KEY)),
      freeplay_api_key=FREEPLAY_API_KEY,
      api_base=f'https://{FREEPLAY_CUSTOMER_NAME}.freeplay.ai/api'
  )

  completion_stream = fp_client.get_completion_stream(
      project_id=FREEPLAY_PROJECT_ID,
      template_name="album_bot",
      variables={"pop_star": "Bruno Mars"}
  )

  for chunk in completion_stream:
      print("Chunk: %s" % chunk.text.strip())


  ```

  ```javascript node theme={null}
  import * as freeplay from "freeplay";

  async function main() {
    const FREEPLAY_API_KEY = process.env["FREEPLAY_API_KEY"]
    const OPENAI_API_KEY = process.env["OPENAI_API_KEY"]
    const FREEPLAY_CUSTOMER_NAME = process.env["FREEPLAY_CUSTOMER_NAME"]
    const FREEPLAY_PROJECT_ID = process.env["FREEPLAY_PROJECT_ID"]

    const fp_client = new freeplay.Freeplay({
      freeplayApiKey: FREEPLAY_API_KEY,
      baseUrl: `https://${FREEPLAY_CUSTOMER_NAME}.freeplay.ai/api`,
      providerConfig: {
        openai: {
          apiKey: OPENAI_API_KEY
        }
      }
  	})

    const completionStream = await fp_client.getCompletionStream({
      projectId: FREEPLAY_PROJECT_ID,
      templateName: "album_bot",
      variables: {
        ["pop_star"]: "Bruno Mars"
      }
    })

    for await (const chunk of completionStream) {
    if (chunk.choices[0].role) {
      process.stdout.write(`${chunk.choices[0].role} message: `);
    }
      process.stdout.write(chunk.content);
    }
    console.log('\n')
  }

  main();

  ```

  ```kotlin kotlin theme={null}
  package ai.freeplay.example.java;

  import ai.freeplay.client.Freeplay;
  import ai.freeplay.client.ProviderConfig.OpenAIProviderConfig;
  import ai.freeplay.client.model.ChatMessage;
  import ai.freeplay.client.model.CompletionResponse;
  import ai.freeplay.client.model.CompletionSession;

  import java.util.Collections;
  import java.util.Map;
  import java.util.stream.Stream;

  import static java.lang.String.format;

  public class StreamingExample {

      public static void main(String[] args) {
          String openaiApiKey = System.getenv("OPENAI_API_KEY");
          String freeplayApiKey = System.getenv("FREEPLAY_API_KEY");
          String projectId = System.getenv("FREEPLAY_PROJECT_ID");
          String customerDomain = System.getenv("FREEPLAY_CUSTOMER_NAME");

          String baseUrl = format("https://%s.freeplay.ai/api", customerDomain);

          Freeplay fpClient = new Freeplay(freeplayApiKey, baseUrl, new OpenAIProviderConfig(openaiApiKey));
          Map<String, Object> llmParameters = Collections.emptyMap();

          CompletionSession session = fpClient.createSession(projectId, "prod");

          Stream<ChatMessage> completionStream = session.getCompletionStream(
                  "my-chat-start",
                  Map.of("question", "why isn't my sink working?"),
                  llmParameters,
                  null,
                  null
          );
          completionStream.forEach((ChatMessage chunk) -> {
              System.out.printf("Message [%s]: %s%n", chunk.getRole(), chunk.getContent());
          });

          Stream<CompletionResponse> textStream = session.getCompletionStream(
                  "my-prompt",
                  Map.of("question", "why isn't my sink working?"),
                  llmParameters,
                  null,
                  null
          );
          textStream.forEach((CompletionResponse chunk) -> {
              System.out.printf("Message [TEXT]: %s%n", chunk.getContent());
          });
      }
  }


  ```
</CodeGroup>