Use the Streaming Feature of the Kimi API

from openai import OpenAI
 
client = OpenAI(
    api_key = "MOONSHOT_API_KEY", # Replace MOONSHOT_API_KEY with the API Key you obtained from the Kimi Open Platform
    base_url = "https://api.moonshot.ai/v1",
)
 
stream = client.chat.completions.create(
    model = "kimi-k2.5",
    messages = [
        {"role": "system", "content": "You are Kimi, an artificial intelligence assistant provided by Moonshot AI, who is better at conversing in Chinese and English. You provide users with safe, helpful, and accurate answers. At the same time, you refuse to answer any questions related to terrorism, racism, pornography, and violence. Moonshot AI is a proper noun and should not be translated into other languages."},
        {"role": "user", "content": "Hello, my name is Li Lei, what is 1+1?"}
    ],
    stream=True, # <-- Note here, we enable streaming output mode by setting stream=True
)
 
# When streaming output mode is enabled (stream=True), the content returned by the SDK also changes. We no longer directly access the choice in the return value
# Instead, we access each individual chunk in the return value through a for loop
 
for chunk in stream:
	# Here, the structure of each chunk is similar to the previous completion, but the message field is replaced with the delta field
	delta = chunk.choices[0].delta # <-- The message field is replaced with the delta field
 
	if delta.content:
		# When printing the content, since it is streaming output, to ensure the coherence of the sentence, we do not add
		# line breaks manually, so we set end="" to cancel the line break of print.
		print(delta.content, end="")

import os
import httpx
from openai import OpenAI
 
client = OpenAI(
    api_key = "MOONSHOT_API_KEY", # Replace MOONSHOT_API_KEY with the API Key you obtained from the Kimi Open Platform
    base_url = "https://api.moonshot.ai/v1",
)
 
stream = client.chat.completions.create(
    model = "kimi-k2.5",
    messages = [
        {"role": "system", "content": "You are Kimi, an AI assistant provided by Moonshot AI, who excels in Chinese and English conversations. You provide users with safe, helpful, and accurate answers while rejecting any questions related to terrorism, racism, or explicit content. Moonshot AI is a proper noun and should not be translated."},
        {"role": "user", "content": "Hello, my name is Li Lei. What is 1+1?"}
    ],
    stream=True, # <-- Note here, we enable streaming output mode by setting stream=True
)
 
 
def estimate_token_count(input: str) -> int:
    """
    Implement your token calculation logic here, or directly call our token calculation interface to compute tokens.
 
    https://api.moonshot.ai/v1/tokenizers/estimate-token-count
    """
    header = {
        "Authorization": f"Bearer {os.environ['MOONSHOT_API_KEY']}",
    }
    data = {
        "model": "kimi-k2.5",
        "messages": [
            {"role": "user", "content": input},
        ]
    }
    r = httpx.post("https://api.moonshot.ai/v1/tokenizers/estimate-token-count", headers=header, json=data)
    r.raise_for_status()
    return r.json()["data"]["total_tokens"]
 
 
completion = []
for chunk in stream:
	delta = chunk.choices[0].delta
	if delta.content:
		completion.append(delta.content)
 
 
print("completion_tokens:", estimate_token_count("".join(completion)))

import httpx # We use the httpx library to make our HTTP requests
 
 
data = {
	"model": "kimi-k2.5",
	"messages": [
		# Specific messages
	],
	"stream": True,
}
 
 
# Use httpx to send a chat request to the Kimi large language model and get the response r
r = httpx.post("https://api.moonshot.ai/v1/chat/completions", json=data)
if r.status_code != 200:
	raise Exception(r.text)
 
 
data: str
 
# Here, we use the iter_lines method to read the response body line by line
for line in r.iter_lines():
	# Remove leading and trailing spaces from each line to better handle data chunks
	line = line.strip()
 
	# Next, we need to handle three different cases:
	#   1. If the current line is empty, it indicates that the previous data chunk has been received (as mentioned earlier, the data chunk transmission ends with two newline characters), we can deserialize the data chunk and print the corresponding content;
	#   2. If the current line is not empty and starts with data:, it indicates the start of a data chunk transmission, we remove the data: prefix and first check if it is the end symbol [DONE], if not, save the data content to the data variable;
	#   3. If the current line is not empty but does not start with data:, it indicates that the current line still belongs to the previous data chunk being transmitted, we append the content of the current line to the end of the data variable;
 
	if len(line) == 0:
		chunk = json.loads(data)
 
		# The processing logic here can be replaced with your business logic, printing is just to demonstrate the process
		choice = chunk["choices"][0]
		usage = choice.get("usage")
		if usage:
			print("total_tokens:", usage["total_tokens"])
		delta = choice["delta"]
		role = delta.get("role")
		if role:
			print("role:", role)
		content = delta.get("content")
		if content:
			print(content, end="")
 
		data = "" # Reset data
	elif line.startswith("data: "):
		data = line.lstrip("data: ")
 
		# When the data chunk content is [DONE], it indicates that all data chunks have been sent, and the network connection can be disconnected
		if data == "[DONE]":
			break
	else:
		data = data + "\n" + line # We still add a newline character when appending content, as this data chunk may intentionally format the data in separate lines

import httpx # We use the httpx library to make our HTTP requests
 
 
data = {
	"model": "kimi-k2.5",
	"messages": [
		# Specific messages go here
	],
	"stream": True,
	"n": 2, # <-- Note here, we're asking the Kimi large language model to output 2 responses
}
 
 
# Use httpx to send a chat request to the Kimi large language model and get the response r
r = httpx.post("https://api.moonshot.ai/v1/chat/completions", json=data)
if r.status_code != 200:
	raise Exception(r.text)
 
 
data: str
 
# Here, we pre-build a List to store different response messages. Since we set n=2, we initialize the List with 2 elements
messages = [{}, {}]
 
# We use the iter_lines method here to read the response body line by line
for line in r.iter_lines():
	# Remove leading and trailing spaces from each line to better handle data blocks
	line = line.strip()
 
	# Next, we need to handle three different scenarios:
	#   1. If the current line is empty, it indicates that the previous data block has been fully received (as mentioned earlier, data block transmission ends with two newline characters). We can deserialize this data block and print out the corresponding content;
	#   2. If the current line is not empty and starts with data:, it means the start of a data block transmission. After removing the data: prefix, we first check if it's the end marker [DONE]. If not, we save the data content to the data variable;
	#   3. If the current line is not empty but doesn't start with data:, it means this line still belongs to the previous data block being transmitted. We append the content of this line to the end of the data variable;
 
	if len(line) == 0:
		chunk = json.loads(data)
 
		# Loop through all choices in each data block to get the message object corresponding to the index
		for choice in chunk["choices"]:
			index = choice["index"]
			message = messages[index]
			usage = choice.get("usage")
			if usage:
				message["usage"] = usage
			delta = choice["delta"]
			role = delta.get("role")
			if role:
				message["role"] = role
			content = delta.get("content")
			if content:
				message["content"] = message.get("content", "") + content
 
			data = "" # Reset data
	elif line.startswith("data: "):
		data = line.lstrip("data: ")
 
		# When the data block content is [DONE], it means all data blocks have been sent and we can disconnect the network
		if data == "[DONE]":
			break
	else:
		data = data + "\n" + line # When we're still appending content, we add a newline character because this might be the data block's intentional way of displaying data on separate lines
 
 
# After assembling all messages, we print their contents separately
for index, message in enumerate(messages):
	print("index:", index)
	print("message:", json.dumps(message, ensure_ascii=False))