Your task is to review pull requests. Instructions:
- Provide the response in following JSON format: {"reviews": [{"line": <line_number>, "body": "<review comment>"}]}
- Do not give positive comments or compliments.
- Provide comments and suggestions ONLY if there is something to improve, otherwise "reviews" should be an empty array.
- Write the comment in GitHub Markdown format.
- Use the given description only for the overall context and only comment the code.
- IMPORTANT: NEVER suggest adding comments to the code.

Review the following code diff in the file "docs/interference-api.md" and take the pull request title and description into account when writing the response.
  
Pull request title: [pull] main from xtekky:main
Pull request description:
---
See Commits and Changes for more details.

-----
Created by [<img src="https://prod.download/pull-18h-svg" valign="bottom"/> **pull[bot]**](https://github.com/wei/pull)

_Can you help keep this open source service alive? **[💖 Please sponsor : )](https://prod.download/pull-pr-sponsor)**_
---

Each line is prefixed by its number. Code to review:
```
-
1: # G4F - Interference API Usage Guide
-
2:+  
3: 
4: ## Table of Contents
5:    - [Introduction](#introduction)
6:    - [Running the Interference API](#running-the-interference-api)
7:    - [From PyPI Package](#from-pypi-package)
8:    - [From Repository](#from-repository)
-   - [Usage with OpenAI Library](#usage-with-openai-library)
-   - [Usage with Requests Library](#usage-with-requests-library)
9:+   - [Using the Interference API](#using-the-interference-api)
10:+   - [Basic Usage](#basic-usage)
11:+   - [With OpenAI Library](#with-openai-library)
12:+   - [With Requests Library](#with-requests-library)
13:    - [Key Points](#key-points)
14:+   - [Conclusion](#conclusion)
15:+  
16: 
17: ## Introduction
-The Interference API allows you to serve other OpenAI integrations with G4F. It acts as a proxy, translating requests to the OpenAI API into requests to the G4F providers.
18:+The G4F Interference API is a powerful tool that allows you to serve other OpenAI integrations using G4F (Gpt4free). It acts as a proxy, translating requests intended for the OpenAI API into requests compatible with G4F providers. This guide will walk you through the process of setting up, running, and using the Interference API effectively.
19:+  
20: 
21: ## Running the Interference API
22:+**You can run the Interference API in two ways:** using the PyPI package or from the repository.
23:+  
24: 
25: ### From PyPI Package
-**You can run the Interference API directly from the G4F PyPI package:**
26:+**To run the Interference API directly from the G4F PyPI package, use the following Python code:**
27:+
28: ```python
29: from g4f.api import run_api
30: 
32: ```
33: 
34:   
-
35: ### From Repository
-Alternatively, you can run the Interference API from the cloned repository.  
36:+**If you prefer to run the Interference API from the cloned repository, you have two options:**
37: 
-**Run the server with:**
38:+1. **Using the command line:**
39: ```bash
40: g4f api
41: ```
-or
42:+
43:+2. **Using Python:**
44: ```bash
45: python -m g4f.api.run
46: ```
47: 
48:+**Once running, the API will be accessible at:** `http://localhost:1337/v1`
49:   
50: 
-## Usage with OpenAI Library
51:+## Using the Interference API
52: 
-  
53:+### Basic Usage
54:+**You can interact with the Interference API using curl commands for both text and image generation:**
55: 
56:+**For text generation:**
57:+```bash
58:+curl -X POST "http://localhost:1337/v1/chat/completions" \
59:+     -H "Content-Type: application/json" \
60:+     -d '{
61:+           "messages": [
62:+             {
63:+               "role": "user",
64:+               "content": "Hello"
65:+             }
66:+           ],
67:+           "model": "gpt-3.5-turbo"
68:+         }'
69:+```
70:+
71:+**For image generation:**
72:+1. **url:**
73:+```bash
74:+curl -X POST "http://localhost:1337/v1/images/generate" \
75:+     -H "Content-Type: application/json" \
76:+     -d '{
77:+           "prompt": "a white siamese cat",
78:+           "model": "flux",
79:+           "response_format": "url"
80:+         }'
81:+```
82:+
83:+2. **b64_json**
84:+```bash
85:+curl -X POST "http://localhost:1337/v1/images/generate" \
86:+     -H "Content-Type: application/json" \
87:+     -d '{
88:+           "prompt": "a white siamese cat",
89:+           "model": "flux",
90:+           "response_format": "b64_json"
91:+         }'
92:+```
93:+
94:+
95:+### With OpenAI Library
96:+
97:+**You can use the Interference API with the OpenAI Python library by changing the `base_url`:**
98: ```python
99: from openai import OpenAI
100: 
101: client = OpenAI(
102:     api_key="",
-    # Change the API base URL to the local interference API
-    base_url="http://localhost:1337/v1"  
103:+    base_url="http://localhost:1337/v1"
104: )
105: 
106: response = client.chat.completions.create(
107:     model="gpt-3.5-turbo",
-    messages=[{"role": "user", "content": "write a poem about a tree"}],
108:+    messages=[{"role": "user", "content": "Write a poem about a tree"}],
109:     stream=True,
110: )
111: 
118:         content = token.choices[0].delta.content
119:         if content is not None:
120:             print(content, end="", flush=True)
-```
121: 
122:+```
123:   
124: 
-## Usage with Requests Library
-You can also send requests directly to the Interference API using the requests library. 
125:+### With Requests Library
126: 
-**Send a POST request to `/v1/chat/completions` with the request body containing the model and other parameters:**
127:+**You can also send requests directly to the Interference API using the `requests` library:**
128: ```python
129: import requests
130: 
131: url = "http://localhost:1337/v1/chat/completions"
132:+
133: body = {
-    "model": "gpt-3.5-turbo", 
134:+    "model": "gpt-3.5-turbo",
135:     "stream": False,
136:     "messages": [
137:         {"role": "assistant", "content": "What can you do?"}
142: 
143: for choice in json_response:
144:     print(choice.get('message', {}).get('content', ''))
-```
145: 
-  
146:+```
147: 
148: ## Key Points
-- The Interference API translates OpenAI API requests into G4F provider requests
-- You can run it from the PyPI package or the cloned repository
-- It supports usage with the OpenAI Python library by changing the `base_url`
-- Direct requests can be sent to the API endpoints using libraries like `requests`
149:+   - The Interference API translates OpenAI API requests into G4F provider requests.
150:+   - It can be run from either the PyPI package or the cloned repository.
151:+   - The API supports usage with the OpenAI Python library by changing the `base_url`.
152:+   - Direct requests can be sent to the API endpoints using libraries like `requests`.
153:+   - Both text and image generation are supported.
154: 
155:   
-**_The Interference API allows easy integration of G4F with existing OpenAI-based applications and tools._**
156:+## Conclusion
157:+The G4F Interference API provides a seamless way to integrate G4F with existing OpenAI-based applications and tools. By following this guide, you should now be able to set up, run, and use the Interference API effectively. Whether you're using it for text generation, image creation, or as a drop-in replacement for OpenAI in your projects, the Interference API offers flexibility and power for your AI-driven applications.
158:+ 
159: 
160: ---
161: 
```