├── .gitignore ├── LICENSE ├── README.md ├── default ├── experiment ├── generateMetaPrompt.js ├── generateMetaPromptHTML.js ├── gpt.js ├── html-snippets │ ├── classifier-classify-text-image.html │ ├── classifier-classify-text.html │ ├── classifier-manage.html │ ├── classifier-train-text-image.html │ ├── classifier-train-text.html │ ├── embeddings.html │ ├── g.reader.html │ ├── r.reader.html │ ├── reranker.html │ ├── s.reader.html │ └── segmenter.html ├── index-gen.txt ├── package-lock.json ├── package.json ├── run-tests.js ├── test-cases-tiny.json ├── test-cases.json ├── test-cases │ ├── books.txt │ ├── docsqa.txt │ ├── papers.txt │ └── recipes.txt └── testResults │ ├── requirements.txt │ ├── v0 │ ├── 0-batch-embedding.py │ ├── 0-hackernews.py │ ├── 1-image-rerank.py │ ├── 10-docsqa.py │ ├── 11-papers.py │ ├── 12-recipes.py │ ├── 2-batch-embedding.py │ ├── 3-embedding for classification.py │ ├── 4-embedding late chunking.py │ ├── 5-embedding binary return type.py │ ├── 6-re-rank.py │ ├── 7-reader-grounding.py │ ├── 8-reader-grounding.py │ └── 9-books.py │ ├── v1 │ ├── 0-batch-embedding.py │ ├── 0-hackernews.py │ ├── 1-image-rerank.py │ ├── 10-docsqa.py │ ├── 11-papers.py │ ├── 12-recipes.py │ ├── 2-batch-embedding.py │ ├── 3-embedding for classification.py │ ├── 4-embedding late chunking.py │ ├── 5-embedding binary return type.py │ ├── 6-re-rank.py │ ├── 7-reader-grounding.py │ ├── 8-reader-grounding.py │ └── 9-books.py │ ├── v2 │ ├── 0-batch-embedding.py │ ├── 0-hackernews.py │ ├── 1-image-rerank.py │ ├── 10-docsqa.py │ ├── 11-papers.py │ ├── 12-recipes.py │ ├── 2-batch-embedding.py │ ├── 3-embedding for classification.py │ ├── 4-embedding late chunking.py │ ├── 5-embedding binary return type.py │ ├── 6-re-rank.py │ ├── 7-reader-grounding.py │ ├── 8-reader-grounding.py │ └── 9-books.py │ ├── v3 │ ├── 0-batch-embedding.py │ ├── 0-hackernews.py │ ├── 1-image-rerank.py │ ├── 10-docsqa.py │ ├── 11-papers.py │ ├── 12-recipes.py │ ├── 2-batch-embedding.py │ ├── 3-embedding for classification.py │ ├── 4-embedding late chunking.py │ ├── 5-embedding binary return type.py │ ├── 6-re-rank.py │ ├── 7-reader-grounding.py │ ├── 8-reader-grounding.py │ └── 9-books.py │ └── v4 │ ├── 0-hackernews.py │ ├── 1-image-rerank.py │ ├── 10-docsqa.py │ ├── 11-papers.py │ ├── 12-recipes.py │ ├── 2-batch-embedding.py │ ├── 3-embedding for classification.py │ ├── 4-embedding late chunking.py │ ├── 5-embedding binary return type.py │ ├── 6-re-rank.py │ ├── 7-reader-grounding.py │ ├── 8-reader-grounding.py │ └── 9-books.py ├── headers.json ├── index.html ├── v0.txt ├── v1.txt ├── v2.txt ├── v3.txt ├── v4.txt ├── v5.txt ├── v6.txt └── v7.txt /.gitignore: -------------------------------------------------------------------------------- 1 | node_modules 2 | experiment/testResults/venv -------------------------------------------------------------------------------- /LICENSE: -------------------------------------------------------------------------------- 1 | Apache License 2 | Version 2.0, January 2004 3 | http://www.apache.org/licenses/ 4 | 5 | TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION 6 | 7 | 1. Definitions. 8 | 9 | "License" shall mean the terms and conditions for use, reproduction, 10 | and distribution as defined by Sections 1 through 9 of this document. 11 | 12 | "Licensor" shall mean the copyright owner or entity authorized by 13 | the copyright owner that is granting the License. 14 | 15 | "Legal Entity" shall mean the union of the acting entity and all 16 | other entities that control, are controlled by, or are under common 17 | control with that entity. For the purposes of this definition, 18 | "control" means (i) the power, direct or indirect, to cause the 19 | direction or management of such entity, whether by contract or 20 | otherwise, or (ii) ownership of fifty percent (50%) or more of the 21 | outstanding shares, or (iii) beneficial ownership of such entity. 22 | 23 | "You" (or "Your") shall mean an individual or Legal Entity 24 | exercising permissions granted by this License. 25 | 26 | "Source" form shall mean the preferred form for making modifications, 27 | including but not limited to software source code, documentation 28 | source, and configuration files. 29 | 30 | "Object" form shall mean any form resulting from mechanical 31 | transformation or translation of a Source form, including but 32 | not limited to compiled object code, generated documentation, 33 | and conversions to other media types. 34 | 35 | "Work" shall mean the work of authorship, whether in Source or 36 | Object form, made available under the License, as indicated by a 37 | copyright notice that is included in or attached to the work 38 | (an example is provided in the Appendix below). 39 | 40 | "Derivative Works" shall mean any work, whether in Source or Object 41 | form, that is based on (or derived from) the Work and for which the 42 | editorial revisions, annotations, elaborations, or other modifications 43 | represent, as a whole, an original work of authorship. For the purposes 44 | of this License, Derivative Works shall not include works that remain 45 | separable from, or merely link (or bind by name) to the interfaces of, 46 | the Work and Derivative Works thereof. 47 | 48 | "Contribution" shall mean any work of authorship, including 49 | the original version of the Work and any modifications or additions 50 | to that Work or Derivative Works thereof, that is intentionally 51 | submitted to Licensor for inclusion in the Work by the copyright owner 52 | or by an individual or Legal Entity authorized to submit on behalf of 53 | the copyright owner. For the purposes of this definition, "submitted" 54 | means any form of electronic, verbal, or written communication sent 55 | to the Licensor or its representatives, including but not limited to 56 | communication on electronic mailing lists, source code control systems, 57 | and issue tracking systems that are managed by, or on behalf of, the 58 | Licensor for the purpose of discussing and improving the Work, but 59 | excluding communication that is conspicuously marked or otherwise 60 | designated in writing by the copyright owner as "Not a Contribution." 61 | 62 | "Contributor" shall mean Licensor and any individual or Legal Entity 63 | on behalf of whom a Contribution has been received by Licensor and 64 | subsequently incorporated within the Work. 65 | 66 | 2. Grant of Copyright License. Subject to the terms and conditions of 67 | this License, each Contributor hereby grants to You a perpetual, 68 | worldwide, non-exclusive, no-charge, royalty-free, irrevocable 69 | copyright license to reproduce, prepare Derivative Works of, 70 | publicly display, publicly perform, sublicense, and distribute the 71 | Work and such Derivative Works in Source or Object form. 72 | 73 | 3. Grant of Patent License. Subject to the terms and conditions of 74 | this License, each Contributor hereby grants to You a perpetual, 75 | worldwide, non-exclusive, no-charge, royalty-free, irrevocable 76 | (except as stated in this section) patent license to make, have made, 77 | use, offer to sell, sell, import, and otherwise transfer the Work, 78 | where such license applies only to those patent claims licensable 79 | by such Contributor that are necessarily infringed by their 80 | Contribution(s) alone or by combination of their Contribution(s) 81 | with the Work to which such Contribution(s) was submitted. If You 82 | institute patent litigation against any entity (including a 83 | cross-claim or counterclaim in a lawsuit) alleging that the Work 84 | or a Contribution incorporated within the Work constitutes direct 85 | or contributory patent infringement, then any patent licenses 86 | granted to You under this License for that Work shall terminate 87 | as of the date such litigation is filed. 88 | 89 | 4. Redistribution. You may reproduce and distribute copies of the 90 | Work or Derivative Works thereof in any medium, with or without 91 | modifications, and in Source or Object form, provided that You 92 | meet the following conditions: 93 | 94 | (a) You must give any other recipients of the Work or 95 | Derivative Works a copy of this License; and 96 | 97 | (b) You must cause any modified files to carry prominent notices 98 | stating that You changed the files; and 99 | 100 | (c) You must retain, in the Source form of any Derivative Works 101 | that You distribute, all copyright, patent, trademark, and 102 | attribution notices from the Source form of the Work, 103 | excluding those notices that do not pertain to any part of 104 | the Derivative Works; and 105 | 106 | (d) If the Work includes a "NOTICE" text file as part of its 107 | distribution, then any Derivative Works that You distribute must 108 | include a readable copy of the attribution notices contained 109 | within such NOTICE file, excluding those notices that do not 110 | pertain to any part of the Derivative Works, in at least one 111 | of the following places: within a NOTICE text file distributed 112 | as part of the Derivative Works; within the Source form or 113 | documentation, if provided along with the Derivative Works; or, 114 | within a display generated by the Derivative Works, if and 115 | wherever such third-party notices normally appear. The contents 116 | of the NOTICE file are for informational purposes only and 117 | do not modify the License. You may add Your own attribution 118 | notices within Derivative Works that You distribute, alongside 119 | or as an addendum to the NOTICE text from the Work, provided 120 | that such additional attribution notices cannot be construed 121 | as modifying the License. 122 | 123 | You may add Your own copyright statement to Your modifications and 124 | may provide additional or different license terms and conditions 125 | for use, reproduction, or distribution of Your modifications, or 126 | for any such Derivative Works as a whole, provided Your use, 127 | reproduction, and distribution of the Work otherwise complies with 128 | the conditions stated in this License. 129 | 130 | 5. Submission of Contributions. Unless You explicitly state otherwise, 131 | any Contribution intentionally submitted for inclusion in the Work 132 | by You to the Licensor shall be under the terms and conditions of 133 | this License, without any additional terms or conditions. 134 | Notwithstanding the above, nothing herein shall supersede or modify 135 | the terms of any separate license agreement you may have executed 136 | with Licensor regarding such Contributions. 137 | 138 | 6. Trademarks. This License does not grant permission to use the trade 139 | names, trademarks, service marks, or product names of the Licensor, 140 | except as required for reasonable and customary use in describing the 141 | origin of the Work and reproducing the content of the NOTICE file. 142 | 143 | 7. Disclaimer of Warranty. Unless required by applicable law or 144 | agreed to in writing, Licensor provides the Work (and each 145 | Contributor provides its Contributions) on an "AS IS" BASIS, 146 | WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or 147 | implied, including, without limitation, any warranties or conditions 148 | of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A 149 | PARTICULAR PURPOSE. You are solely responsible for determining the 150 | appropriateness of using or redistributing the Work and assume any 151 | risks associated with Your exercise of permissions under this License. 152 | 153 | 8. Limitation of Liability. In no event and under no legal theory, 154 | whether in tort (including negligence), contract, or otherwise, 155 | unless required by applicable law (such as deliberate and grossly 156 | negligent acts) or agreed to in writing, shall any Contributor be 157 | liable to You for damages, including any direct, indirect, special, 158 | incidental, or consequential damages of any character arising as a 159 | result of this License or out of the use or inability to use the 160 | Work (including but not limited to damages for loss of goodwill, 161 | work stoppage, computer failure or malfunction, or any and all 162 | other commercial damages or losses), even if such Contributor 163 | has been advised of the possibility of such damages. 164 | 165 | 9. Accepting Warranty or Additional Liability. While redistributing 166 | the Work or Derivative Works thereof, You may choose to offer, 167 | and charge a fee for, acceptance of support, warranty, indemnity, 168 | or other liability obligations and/or rights consistent with this 169 | License. However, in accepting such obligations, You may act only 170 | on Your own behalf and on Your sole responsibility, not on behalf 171 | of any other Contributor, and only if You agree to indemnify, 172 | defend, and hold each Contributor harmless for any liability 173 | incurred by, or claims asserted against, such Contributor by reason 174 | of your accepting any such warranty or additional liability. 175 | 176 | END OF TERMS AND CONDITIONS 177 | 178 | APPENDIX: How to apply the Apache License to your work. 179 | 180 | To apply the Apache License to your work, attach the following 181 | boilerplate notice, with the fields enclosed by brackets "[]" 182 | replaced with your own identifying information. (Don't include 183 | the brackets!) The text should be enclosed in the appropriate 184 | comment syntax for the file format. We also recommend that a 185 | file or class name and description of purpose be included on the 186 | same "printed page" as the copyright notice for easier 187 | identification within third-party archives. 188 | 189 | Copyright [yyyy] [name of copyright owner] 190 | 191 | Licensed under the Apache License, Version 2.0 (the "License"); 192 | you may not use this file except in compliance with the License. 193 | You may obtain a copy of the License at 194 | 195 | http://www.apache.org/licenses/LICENSE-2.0 196 | 197 | Unless required by applicable law or agreed to in writing, software 198 | distributed under the License is distributed on an "AS IS" BASIS, 199 | WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. 200 | See the License for the specific language governing permissions and 201 | limitations under the License. 202 | -------------------------------------------------------------------------------- /README.md: -------------------------------------------------------------------------------- 1 | # Meta-Prompt for Jina Search Foundation APIs 2 | 3 | ## Usage 4 | - `curl docs.jina.ai`: load default version defined in [`default`](default) 5 | - Specific version: `curl docs.jina.ai/v1` 6 | - Pipe into [`llm`](https://github.com/simonw/llm): 7 | ```bash 8 | curl docs.jina.ai/v1 | llm -s 'grab all sentences from Hacker News, embed them, and visualize the results in a 2D UMAP with matplotlib' -m claude-3.5-sonnet 9 | ``` 10 | 11 | ## Note 12 | - Opening docs.jina.ai in a browser gives you a `text/html` response, but programmatic access gives you a clean `text/plain` response. This is due to the `user-agent` value. 13 | - For browser JS `fetch` where you can't change the `user-agent` or in scenarios where you pretend to be a browser by `user-agent` spoofing, you can add 'accept': 'text/plain' to the header to force the `text/plain` response. 14 | 15 | ## Developer's Guide 16 | - Upload your prompt to `v{x}.txt` in the repository root. 17 | - Use `curl docs.jina.ai/v{x}` to fetch your prompt: 18 | - No need to include `.txt`; simply use `curl docs.jina.ai/v1`, `curl docs.jina.ai/v2`, `curl docs.jina.ai/v3`, etc. 19 | - [`index.html`](index.html) is the `text/html` response template with placeholder variables inside; this file is only for browser/bot view and for human readability. Eye-candy stuff. 20 | - [`headers.json`](headers.json) defines some response header that *may be respected* by AI-browsers/apps in the future; one can use `curl -svo. docs.jina.ai` to check them. 21 | -------------------------------------------------------------------------------- /default: -------------------------------------------------------------------------------- 1 | v7 -------------------------------------------------------------------------------- /experiment/generateMetaPrompt.js: -------------------------------------------------------------------------------- 1 | const https = require('https'); 2 | const fs = require('fs'); 3 | const {promptLLMOpenAI} = require("./gpt"); 4 | 5 | // TODO map all endpoints to the correct production endpoint 6 | // const endpointMapping = { 7 | // '/crawl': 8 | // '/v1/embeddings': 'embeddings.jina.ai' 9 | // } 10 | 11 | const specifications = [ 12 | { 13 | 'product': 'Embeddings', 14 | 'description': 'Generate embeddings for a list of text items', 15 | 'specification': 'https://api.jina.ai/openapi.json', 16 | 'baseURL': 'https://api.jina.ai', 17 | 'endpoint': 'v1/embeddings' 18 | }, 19 | 20 | { 21 | 'product': 'Reader - Single Page', 22 | 'description': 'Retrieve the content of a single web page in an LLM-friendly format', 23 | 'specification': 'https://r.jina.ai/openapi.json', 24 | 'baseURL': 'https://r.jina.ai', 25 | 'endpoint': 'crawl' 26 | }, 27 | { 28 | 'product': 'Reader - Search', 29 | 'description': 'Get search results that are LLM-friendly', 30 | 'specification': 'https://s.jina.ai/openapi.json', 31 | 'baseURL': 'https://s.jina.ai', 32 | 'endpoint': 'search' 33 | }, 34 | { 35 | 'product': 'Reader - Grounding', 36 | 'description': 'Given a statement, find out if it is true or false', 37 | 'specification': 'https://g.jina.ai/openapi.json', 38 | 'baseURL': 'https://g.jina.ai', 39 | 'endpoint': 'checkFact' 40 | } 41 | ]; 42 | 43 | // Function to download JSON from a URL 44 | const downloadJSON = (url) => { 45 | return new Promise((resolve, reject) => { 46 | https.get(url, (response) => { 47 | let data = ''; 48 | response.on('data', (chunk) => { 49 | data += chunk; 50 | }); 51 | response.on('end', () => { 52 | resolve(JSON.parse(data)); 53 | }); 54 | }).on('error', (error) => { 55 | reject(error); 56 | }); 57 | }); 58 | }; 59 | 60 | // Process each mapping item 61 | async function processMappings() { 62 | const file = 'index-gen.txt'; 63 | 64 | // Delete the file if it exists 65 | if (fs.existsSync(file)) { 66 | fs.unlinkSync(file); 67 | console.log(`${file} deleted successfully.`); 68 | } 69 | 70 | for (const item of specifications) { 71 | const openAPISpec = await downloadJSON(item.specification); 72 | const endpointNames = Object.keys(openAPISpec.paths); 73 | const jsonContent = JSON.stringify(openAPISpec, null, 2) 74 | for (const endpointName of endpointNames) { 75 | const prompt = `\ 76 | ${jsonContent} 77 | 78 | Generate the most sophisticated example request possible for the endpoint called "${endpointName}" in curl format and the response of the request. 79 | For all attributes make a comment with the following requirements: 80 | - The comment must be concise 81 | - The comment must indicate if the attribute is optional or required 82 | - The comment must indicate the default value 83 | - The comment must provide an exhaustive list of all possible values for the attribute even if this means the comment is long. Nothing like etc. or similar is allowed.` 84 | const response = await promptLLMOpenAI(prompt, 'gpt-4o') 85 | 86 | fs.appendFileSync(file, '\n' + response); 87 | } 88 | } 89 | } 90 | 91 | // Run the function 92 | processMappings(); 93 | -------------------------------------------------------------------------------- /experiment/generateMetaPromptHTML.js: -------------------------------------------------------------------------------- 1 | const fs = require('fs'); 2 | const path = require('path'); 3 | const { promptLLMOpenAI } = require("./gpt"); 4 | 5 | const htmlSnippetDir = './html-snippets'; // Directory containing HTML snippet files 6 | const outputFile = 'index-gen.txt'; 7 | 8 | // Delete the output file if it exists 9 | if (fs.existsSync(outputFile)) { 10 | fs.unlinkSync(outputFile); 11 | console.log(`${outputFile} deleted successfully.`); 12 | } 13 | 14 | // Function to read HTML files from the directory 15 | const getHtmlFiles = (dir) => { 16 | return fs.readdirSync(dir).filter(file => file.endsWith('.html')); 17 | }; 18 | 19 | // Process each HTML file 20 | async function processHtmlSnippets() { 21 | let metaPrompt = ''; 22 | const htmlFiles = getHtmlFiles(htmlSnippetDir); 23 | 24 | for (const fileName of htmlFiles) { 25 | const filePath = path.join(htmlSnippetDir, fileName); 26 | const fileContent = fs.readFileSync(filePath, 'utf-8'); 27 | const productName = path.basename(fileName, '.html'); 28 | 29 | // - The comment must provide an exhaustive list of all possible values for the attribute even if this means the comment is long. Nothing like etc. or similar is allowed. 30 | 31 | const prompt = `\ 32 | #### start file content 33 | ${fileContent} 34 | #### end file content 35 | 36 | Generate the an example request that contains as many parameters, attributes, header fileds as possible in python format without imports. Also generate the example response of the request. 37 | Make sure to include -H "Accept: application/json" in the request to get a json response. 38 | Instead of the actual jina token put the place holder . 39 | For all parameters, attributes, or header fileds make a comment with the following requirements: 40 | - The comment must be concise 41 | - The comment must indicate if the attribute is optional or required 42 | Note: 43 | - write down an example of a complete json response like this: 44 | { 45 | "code": 200, 46 | "status": 20000, 47 | "data": { 48 | "key": "value" 49 | ... 50 | } 51 | For text, you just describe how the text is structured. For both, describe both. 52 | - you must only generate output in the following format: 53 | ## request 54 | endpoint = f"https://..." # < comment here > 55 | ... # < comment here > 56 | ... 57 | response = requests. ... # < comment here > 58 | ## response formats 59 | ... `; 60 | 61 | // Call the LLM API to get the response 62 | const response = await promptLLMOpenAI(prompt, 'gpt-4o'); 63 | metaPrompt += `\n# ${productName}\n${response}` 64 | // Append the result to the output file 65 | } 66 | metaPrompt = `\ 67 | You must use the Jina APIs for the implementation. 68 | Never decline an implementation because of its complexity. 69 | Generate production-ready code that follows exactly the requirements. 70 | Never use placeholder data. 71 | Always make JSON requests by including the header -H "Accept: application/json". 72 | 73 | Overview of all Jina AI APIs: 74 | Classification API: Given texts or images, classify them into categories 75 | Embeddings API: Given texts or images, generate embeddings. 76 | These embeddings can be used for similarity search, clustering, and other tasks. 77 | r.reader API: Input a single website URL and get an LLM-friendly version of that single website. 78 | This is most useful when you already know where you want to get the information from. 79 | s.reader API: Given a search term, get an LLM-friendly version of all websites in the search results. 80 | This is useful when you don't know where to get the information from, but you just know what you are looking for. 81 | g.reader API: Given a statement, find out if it is true or false. 82 | This is useful for fact-checking, fake news detection, and general knowledge verification. 83 | Re-Ranker API: Given a query and a list of search results, re-rank them. 84 | This is useful for improving the relevance of search results. 85 | Segmenter API: Given a text e.g. the output from r.reader or s.reader, split it into segments. 86 | This is useful for breaking down long texts into smaller, more manageable parts. 87 | Usually this is done to get the chunks that are passed to the embeddings API. 88 | 89 | Note: 90 | For every request to any of the Jina APIs, you must include the header -H "Accept: application/json" to specify that the response should be in JSON format. 91 | It is not JSON by default. So you must explicitly specify it in the request headers. 92 | ` + metaPrompt 93 | fs.appendFileSync(outputFile, metaPrompt); 94 | 95 | console.log(`All HTML files processed and saved to ${outputFile}`); 96 | } 97 | 98 | // Run the function 99 | processHtmlSnippets(); 100 | -------------------------------------------------------------------------------- /experiment/gpt.js: -------------------------------------------------------------------------------- 1 | const { AzureOpenAI } = require("openai"); 2 | 3 | // Load the .env file if it exists 4 | const dotenv = require("dotenv"); 5 | dotenv.config(); 6 | 7 | // You will need to set these environment variables or edit the following values 8 | const endpoint = process.env["AZURE_OPENAI_ENDPOINTS"] || ""; 9 | const apiKey = process.env["AZURE_OPENAI_API_KEYS"] || ""; 10 | const apiVersion = "2024-05-01-preview"; 11 | const deployment = "gpt-4o"; //This must match your deployment name. 12 | require("dotenv/config"); 13 | 14 | async function promptLLMOpenAI(prompt, modelName) { 15 | console.log('\x1b[34m%s\x1b[0m', prompt); 16 | for (let i = 0; i < 5; i++) { 17 | try { 18 | console.log('endpoint', endpoint) 19 | console.log('apiKey', apiKey) 20 | const client = new AzureOpenAI({ endpoint, apiKey, apiVersion, deployment }); 21 | const result = await client.chat.completions.create({ 22 | messages: [ 23 | { role: "system", content: "You are a helpful assistant." }, 24 | { role: "user", content: prompt } 25 | ], 26 | model: modelName, 27 | }); 28 | 29 | const content = result.choices[0].message.content 30 | console.log('\x1b[32m%s\x1b[0m', content); 31 | 32 | return content; 33 | } catch (e) { 34 | console.log('error', e, `retrying ${i} after 10 seconds`) 35 | await new Promise(resolve => setTimeout(resolve, 10000)); 36 | } 37 | } 38 | } 39 | 40 | module.exports = { promptLLMOpenAI }; 41 | -------------------------------------------------------------------------------- /experiment/package-lock.json: -------------------------------------------------------------------------------- 1 | { 2 | "name": "meta-prompt", 3 | "lockfileVersion": 3, 4 | "requires": true, 5 | "packages": { 6 | "": { 7 | "dependencies": { 8 | "axios": "^1.7.7", 9 | "dotenv": "^16.4.5", 10 | "fs": "^0.0.1-security", 11 | "https": "^1.0.0", 12 | "openai": "^4.68.4" 13 | } 14 | }, 15 | "node_modules/@types/node": { 16 | "version": "18.19.59", 17 | "resolved": "https://registry.npmjs.org/@types/node/-/node-18.19.59.tgz", 18 | "integrity": "sha512-vizm2EqwV/7Zay+A6J3tGl9Lhr7CjZe2HmWS988sefiEmsyP9CeXEleho6i4hJk/8UtZAo0bWN4QPZZr83RxvQ==", 19 | "dependencies": { 20 | "undici-types": "~5.26.4" 21 | } 22 | }, 23 | "node_modules/@types/node-fetch": { 24 | "version": "2.6.11", 25 | "resolved": "https://registry.npmjs.org/@types/node-fetch/-/node-fetch-2.6.11.tgz", 26 | "integrity": "sha512-24xFj9R5+rfQJLRyM56qh+wnVSYhyXC2tkoBndtY0U+vubqNsYXGjufB2nn8Q6gt0LrARwL6UBtMCSVCwl4B1g==", 27 | "dependencies": { 28 | "@types/node": "*", 29 | "form-data": "^4.0.0" 30 | } 31 | }, 32 | "node_modules/abort-controller": { 33 | "version": "3.0.0", 34 | "resolved": "https://registry.npmjs.org/abort-controller/-/abort-controller-3.0.0.tgz", 35 | "integrity": "sha512-h8lQ8tacZYnR3vNQTgibj+tODHI5/+l06Au2Pcriv/Gmet0eaj4TwWH41sO9wnHDiQsEj19q0drzdWdeAHtweg==", 36 | "dependencies": { 37 | "event-target-shim": "^5.0.0" 38 | }, 39 | "engines": { 40 | "node": ">=6.5" 41 | } 42 | }, 43 | "node_modules/agentkeepalive": { 44 | "version": "4.5.0", 45 | "resolved": "https://registry.npmjs.org/agentkeepalive/-/agentkeepalive-4.5.0.tgz", 46 | "integrity": "sha512-5GG/5IbQQpC9FpkRGsSvZI5QYeSCzlJHdpBQntCsuTOxhKD8lqKhrleg2Yi7yvMIf82Ycmmqln9U8V9qwEiJew==", 47 | "dependencies": { 48 | "humanize-ms": "^1.2.1" 49 | }, 50 | "engines": { 51 | "node": ">= 8.0.0" 52 | } 53 | }, 54 | "node_modules/asynckit": { 55 | "version": "0.4.0", 56 | "resolved": "https://registry.npmjs.org/asynckit/-/asynckit-0.4.0.tgz", 57 | "integrity": "sha512-Oei9OH4tRh0YqU3GxhX79dM/mwVgvbZJaSNaRk+bshkj0S5cfHcgYakreBjrHwatXKbz+IoIdYLxrKim2MjW0Q==" 58 | }, 59 | "node_modules/axios": { 60 | "version": "1.7.7", 61 | "resolved": "https://registry.npmjs.org/axios/-/axios-1.7.7.tgz", 62 | "integrity": "sha512-S4kL7XrjgBmvdGut0sN3yJxqYzrDOnivkBiN0OFs6hLiUam3UPvswUo0kqGyhqUZGEOytHyumEdXsAkgCOUf3Q==", 63 | "dependencies": { 64 | "follow-redirects": "^1.15.6", 65 | "form-data": "^4.0.0", 66 | "proxy-from-env": "^1.1.0" 67 | } 68 | }, 69 | "node_modules/combined-stream": { 70 | "version": "1.0.8", 71 | "resolved": "https://registry.npmjs.org/combined-stream/-/combined-stream-1.0.8.tgz", 72 | "integrity": "sha512-FQN4MRfuJeHf7cBbBMJFXhKSDq+2kAArBlmRBvcvFE5BB1HZKXtSFASDhdlz9zOYwxh8lDdnvmMOe/+5cdoEdg==", 73 | "dependencies": { 74 | "delayed-stream": "~1.0.0" 75 | }, 76 | "engines": { 77 | "node": ">= 0.8" 78 | } 79 | }, 80 | "node_modules/delayed-stream": { 81 | "version": "1.0.0", 82 | "resolved": "https://registry.npmjs.org/delayed-stream/-/delayed-stream-1.0.0.tgz", 83 | "integrity": "sha512-ZySD7Nf91aLB0RxL4KGrKHBXl7Eds1DAmEdcoVawXnLD7SDhpNgtuII2aAkg7a7QS41jxPSZ17p4VdGnMHk3MQ==", 84 | "engines": { 85 | "node": ">=0.4.0" 86 | } 87 | }, 88 | "node_modules/dotenv": { 89 | "version": "16.4.5", 90 | "resolved": "https://registry.npmjs.org/dotenv/-/dotenv-16.4.5.tgz", 91 | "integrity": "sha512-ZmdL2rui+eB2YwhsWzjInR8LldtZHGDoQ1ugH85ppHKwpUHL7j7rN0Ti9NCnGiQbhaZ11FpR+7ao1dNsmduNUg==", 92 | "engines": { 93 | "node": ">=12" 94 | }, 95 | "funding": { 96 | "url": "https://dotenvx.com" 97 | } 98 | }, 99 | "node_modules/event-target-shim": { 100 | "version": "5.0.1", 101 | "resolved": "https://registry.npmjs.org/event-target-shim/-/event-target-shim-5.0.1.tgz", 102 | "integrity": "sha512-i/2XbnSz/uxRCU6+NdVJgKWDTM427+MqYbkQzD321DuCQJUqOuJKIA0IM2+W2xtYHdKOmZ4dR6fExsd4SXL+WQ==", 103 | "engines": { 104 | "node": ">=6" 105 | } 106 | }, 107 | "node_modules/follow-redirects": { 108 | "version": "1.15.9", 109 | "resolved": "https://registry.npmjs.org/follow-redirects/-/follow-redirects-1.15.9.tgz", 110 | "integrity": "sha512-gew4GsXizNgdoRyqmyfMHyAmXsZDk6mHkSxZFCzW9gwlbtOW44CDtYavM+y+72qD/Vq2l550kMF52DT8fOLJqQ==", 111 | "funding": [ 112 | { 113 | "type": "individual", 114 | "url": "https://github.com/sponsors/RubenVerborgh" 115 | } 116 | ], 117 | "engines": { 118 | "node": ">=4.0" 119 | }, 120 | "peerDependenciesMeta": { 121 | "debug": { 122 | "optional": true 123 | } 124 | } 125 | }, 126 | "node_modules/form-data": { 127 | "version": "4.0.1", 128 | "resolved": "https://registry.npmjs.org/form-data/-/form-data-4.0.1.tgz", 129 | "integrity": "sha512-tzN8e4TX8+kkxGPK8D5u0FNmjPUjw3lwC9lSLxxoB/+GtsJG91CO8bSWy73APlgAZzZbXEYZJuxjkHH2w+Ezhw==", 130 | "dependencies": { 131 | "asynckit": "^0.4.0", 132 | "combined-stream": "^1.0.8", 133 | "mime-types": "^2.1.12" 134 | }, 135 | "engines": { 136 | "node": ">= 6" 137 | } 138 | }, 139 | "node_modules/form-data-encoder": { 140 | "version": "1.7.2", 141 | "resolved": "https://registry.npmjs.org/form-data-encoder/-/form-data-encoder-1.7.2.tgz", 142 | "integrity": "sha512-qfqtYan3rxrnCk1VYaA4H+Ms9xdpPqvLZa6xmMgFvhO32x7/3J/ExcTd6qpxM0vH2GdMI+poehyBZvqfMTto8A==" 143 | }, 144 | "node_modules/formdata-node": { 145 | "version": "4.4.1", 146 | "resolved": "https://registry.npmjs.org/formdata-node/-/formdata-node-4.4.1.tgz", 147 | "integrity": "sha512-0iirZp3uVDjVGt9p49aTaqjk84TrglENEDuqfdlZQ1roC9CWlPk6Avf8EEnZNcAqPonwkG35x4n3ww/1THYAeQ==", 148 | "dependencies": { 149 | "node-domexception": "1.0.0", 150 | "web-streams-polyfill": "4.0.0-beta.3" 151 | }, 152 | "engines": { 153 | "node": ">= 12.20" 154 | } 155 | }, 156 | "node_modules/fs": { 157 | "version": "0.0.1-security", 158 | "resolved": "https://registry.npmjs.org/fs/-/fs-0.0.1-security.tgz", 159 | "integrity": "sha512-3XY9e1pP0CVEUCdj5BmfIZxRBTSDycnbqhIOGec9QYtmVH2fbLpj86CFWkrNOkt/Fvty4KZG5lTglL9j/gJ87w==" 160 | }, 161 | "node_modules/https": { 162 | "version": "1.0.0", 163 | "resolved": "https://registry.npmjs.org/https/-/https-1.0.0.tgz", 164 | "integrity": "sha512-4EC57ddXrkaF0x83Oj8sM6SLQHAWXw90Skqu2M4AEWENZ3F02dFJE/GARA8igO79tcgYqGrD7ae4f5L3um2lgg==" 165 | }, 166 | "node_modules/humanize-ms": { 167 | "version": "1.2.1", 168 | "resolved": "https://registry.npmjs.org/humanize-ms/-/humanize-ms-1.2.1.tgz", 169 | "integrity": "sha512-Fl70vYtsAFb/C06PTS9dZBo7ihau+Tu/DNCk/OyHhea07S+aeMWpFFkUaXRa8fI+ScZbEI8dfSxwY7gxZ9SAVQ==", 170 | "dependencies": { 171 | "ms": "^2.0.0" 172 | } 173 | }, 174 | "node_modules/mime-db": { 175 | "version": "1.52.0", 176 | "resolved": "https://registry.npmjs.org/mime-db/-/mime-db-1.52.0.tgz", 177 | "integrity": "sha512-sPU4uV7dYlvtWJxwwxHD0PuihVNiE7TyAbQ5SWxDCB9mUYvOgroQOwYQQOKPJ8CIbE+1ETVlOoK1UC2nU3gYvg==", 178 | "engines": { 179 | "node": ">= 0.6" 180 | } 181 | }, 182 | "node_modules/mime-types": { 183 | "version": "2.1.35", 184 | "resolved": "https://registry.npmjs.org/mime-types/-/mime-types-2.1.35.tgz", 185 | "integrity": "sha512-ZDY+bPm5zTTF+YpCrAU9nK0UgICYPT0QtT1NZWFv4s++TNkcgVaT0g6+4R2uI4MjQjzysHB1zxuWL50hzaeXiw==", 186 | "dependencies": { 187 | "mime-db": "1.52.0" 188 | }, 189 | "engines": { 190 | "node": ">= 0.6" 191 | } 192 | }, 193 | "node_modules/ms": { 194 | "version": "2.1.3", 195 | "resolved": "https://registry.npmjs.org/ms/-/ms-2.1.3.tgz", 196 | "integrity": "sha512-6FlzubTLZG3J2a/NVCAleEhjzq5oxgHyaCU9yYXvcLsvoVaHJq/s5xXI6/XXP6tz7R9xAOtHnSO/tXtF3WRTlA==" 197 | }, 198 | "node_modules/node-domexception": { 199 | "version": "1.0.0", 200 | "resolved": "https://registry.npmjs.org/node-domexception/-/node-domexception-1.0.0.tgz", 201 | "integrity": "sha512-/jKZoMpw0F8GRwl4/eLROPA3cfcXtLApP0QzLmUT/HuPCZWyB7IY9ZrMeKw2O/nFIqPQB3PVM9aYm0F312AXDQ==", 202 | "funding": [ 203 | { 204 | "type": "github", 205 | "url": "https://github.com/sponsors/jimmywarting" 206 | }, 207 | { 208 | "type": "github", 209 | "url": "https://paypal.me/jimmywarting" 210 | } 211 | ], 212 | "engines": { 213 | "node": ">=10.5.0" 214 | } 215 | }, 216 | "node_modules/node-fetch": { 217 | "version": "2.7.0", 218 | "resolved": "https://registry.npmjs.org/node-fetch/-/node-fetch-2.7.0.tgz", 219 | "integrity": "sha512-c4FRfUm/dbcWZ7U+1Wq0AwCyFL+3nt2bEw05wfxSz+DWpWsitgmSgYmy2dQdWyKC1694ELPqMs/YzUSNozLt8A==", 220 | "dependencies": { 221 | "whatwg-url": "^5.0.0" 222 | }, 223 | "engines": { 224 | "node": "4.x || >=6.0.0" 225 | }, 226 | "peerDependencies": { 227 | "encoding": "^0.1.0" 228 | }, 229 | "peerDependenciesMeta": { 230 | "encoding": { 231 | "optional": true 232 | } 233 | } 234 | }, 235 | "node_modules/openai": { 236 | "version": "4.68.4", 237 | "resolved": "https://registry.npmjs.org/openai/-/openai-4.68.4.tgz", 238 | "integrity": "sha512-LRinV8iU9VQplkr25oZlyrsYGPGasIwYN8KFMAAFTHHLHjHhejtJ5BALuLFrkGzY4wfbKhOhuT+7lcHZ+F3iEA==", 239 | "dependencies": { 240 | "@types/node": "^18.11.18", 241 | "@types/node-fetch": "^2.6.4", 242 | "abort-controller": "^3.0.0", 243 | "agentkeepalive": "^4.2.1", 244 | "form-data-encoder": "1.7.2", 245 | "formdata-node": "^4.3.2", 246 | "node-fetch": "^2.6.7" 247 | }, 248 | "bin": { 249 | "openai": "bin/cli" 250 | }, 251 | "peerDependencies": { 252 | "zod": "^3.23.8" 253 | }, 254 | "peerDependenciesMeta": { 255 | "zod": { 256 | "optional": true 257 | } 258 | } 259 | }, 260 | "node_modules/proxy-from-env": { 261 | "version": "1.1.0", 262 | "resolved": "https://registry.npmjs.org/proxy-from-env/-/proxy-from-env-1.1.0.tgz", 263 | "integrity": "sha512-D+zkORCbA9f1tdWRK0RaCR3GPv50cMxcrz4X8k5LTSUD1Dkw47mKJEZQNunItRTkWwgtaUSo1RVFRIG9ZXiFYg==" 264 | }, 265 | "node_modules/tr46": { 266 | "version": "0.0.3", 267 | "resolved": "https://registry.npmjs.org/tr46/-/tr46-0.0.3.tgz", 268 | "integrity": "sha512-N3WMsuqV66lT30CrXNbEjx4GEwlow3v6rr4mCcv6prnfwhS01rkgyFdjPNBYd9br7LpXV1+Emh01fHnq2Gdgrw==" 269 | }, 270 | "node_modules/undici-types": { 271 | "version": "5.26.5", 272 | "resolved": "https://registry.npmjs.org/undici-types/-/undici-types-5.26.5.tgz", 273 | "integrity": "sha512-JlCMO+ehdEIKqlFxk6IfVoAUVmgz7cU7zD/h9XZ0qzeosSHmUJVOzSQvvYSYWXkFXC+IfLKSIffhv0sVZup6pA==" 274 | }, 275 | "node_modules/web-streams-polyfill": { 276 | "version": "4.0.0-beta.3", 277 | "resolved": "https://registry.npmjs.org/web-streams-polyfill/-/web-streams-polyfill-4.0.0-beta.3.tgz", 278 | "integrity": "sha512-QW95TCTaHmsYfHDybGMwO5IJIM93I/6vTRk+daHTWFPhwh+C8Cg7j7XyKrwrj8Ib6vYXe0ocYNrmzY4xAAN6ug==", 279 | "engines": { 280 | "node": ">= 14" 281 | } 282 | }, 283 | "node_modules/webidl-conversions": { 284 | "version": "3.0.1", 285 | "resolved": "https://registry.npmjs.org/webidl-conversions/-/webidl-conversions-3.0.1.tgz", 286 | "integrity": "sha512-2JAn3z8AR6rjK8Sm8orRC0h/bcl/DqL7tRPdGZ4I1CjdF+EaMLmYxBHyXuKL849eucPFhvBoxMsflfOb8kxaeQ==" 287 | }, 288 | "node_modules/whatwg-url": { 289 | "version": "5.0.0", 290 | "resolved": "https://registry.npmjs.org/whatwg-url/-/whatwg-url-5.0.0.tgz", 291 | "integrity": "sha512-saE57nupxk6v3HY35+jzBwYa0rKSy0XR8JSxZPwgLr7ys0IBzhGviA1/TUGJLmSVqs8pb9AnvICXEuOHLprYTw==", 292 | "dependencies": { 293 | "tr46": "~0.0.3", 294 | "webidl-conversions": "^3.0.0" 295 | } 296 | } 297 | } 298 | } 299 | -------------------------------------------------------------------------------- /experiment/package.json: -------------------------------------------------------------------------------- 1 | { 2 | "dependencies": { 3 | "axios": "^1.7.7", 4 | "dotenv": "^16.4.5", 5 | "fs": "^0.0.1-security", 6 | "https": "^1.0.0", 7 | "openai": "^4.68.4" 8 | } 9 | } 10 | -------------------------------------------------------------------------------- /experiment/run-tests.js: -------------------------------------------------------------------------------- 1 | const { promptLLMOpenAI } = require("./gpt"); 2 | const fs = require('fs'); 3 | const path = require('path'); 4 | // let testCases = require('./test-cases.json'); 5 | let testCases = []; 6 | const { execSync } = require('child_process'); // Import execSync correctly 7 | 8 | const additionalTestCases = fs.readdirSync('test-cases').map(file => { 9 | const filePath = path.join('test-cases', file); 10 | const name = file.split('.')[0]; 11 | const prompt = fs.readFileSync(filePath, 'utf-8'); 12 | return { name, prompt }; 13 | }); 14 | testCases = testCases.concat(additionalTestCases); 15 | 16 | async function evaluate(version) { 17 | const versionFolder = `testResults/v${version}`; 18 | const venvPath = path.join('testResults', 'venv', 'bin', 'python'); 19 | const testFiles = fs.readdirSync(versionFolder).filter(file => file.endsWith('.py')); 20 | 21 | let correctCount = 0; 22 | 23 | for (const testFile of testFiles) { 24 | const filePath = path.join(versionFolder, testFile); 25 | 26 | try { 27 | const output = execSync(`${venvPath} ${filePath}`, { encoding: 'utf-8' }); 28 | const prompt = `Given the following program output:\n\n${output}\n\nDoes this output indicate the program works correctly? Respond with either "correct" or "incorrect" and nothing else.`; 29 | 30 | const evaluation = await promptLLMOpenAI(prompt, 'gpt-4o').then(res => res.trim()); 31 | 32 | if (evaluation === 'correct') { 33 | correctCount += 1; 34 | } 35 | } catch (error) { 36 | console.error(`Error executing file ${testFile}: ${error.message}`); 37 | } 38 | } 39 | 40 | // Calculate the percentage of correct programs 41 | const totalTests = testFiles.length; 42 | return (correctCount / totalTests) * 100; 43 | } 44 | 45 | 46 | async function main(versions = [4], isSelfEvaluation = false) { 47 | const scores = {}; 48 | for (const version of versions) { 49 | const metaPromptPath = `../v${version}.txt`; 50 | if (!fs.existsSync(metaPromptPath)) { 51 | console.log(`Prompt file for version v${version} not found at ${metaPromptPath}`); 52 | continue; 53 | } 54 | 55 | const metaPrompt = fs.readFileSync(metaPromptPath, 'utf-8'); 56 | const versionFolder = `testResults/v${version}`; 57 | 58 | if (!fs.existsSync(versionFolder)) { 59 | fs.mkdirSync(versionFolder, { recursive: true }); 60 | } 61 | 62 | const batchSize = 10; 63 | for (let i = 0; i < testCases.length; i += batchSize) { 64 | const batch = testCases.slice(i, i + batchSize).map(async (testCase, index) => { 65 | const prompt = `\ 66 | ${testCase.prompt} 67 | Generate the python code without any other wrapping elements or text. 68 | You can read the authentication token from the environment variable "JINA_API_KEY". 69 | Also no code fencing like \`\`\`python is allowed 70 | ${metaPrompt}`; 71 | 72 | const response = await promptLLMOpenAI(prompt, 'gpt-4o'); 73 | const filePath = path.join(versionFolder, `${i + index}-${testCase.name}.py`); 74 | fs.writeFileSync(filePath, response); 75 | console.log(`Saved result for test case "${testCase.name}" in ${filePath}`); 76 | }); 77 | await Promise.all(batch); 78 | } 79 | if (isSelfEvaluation) { 80 | scores[version] = await evaluate(version); 81 | } 82 | console.log('scores so far', scores); 83 | } 84 | } 85 | 86 | main([0, 1, 2, 3, 4], false); 87 | -------------------------------------------------------------------------------- /experiment/test-cases-tiny.json: -------------------------------------------------------------------------------- 1 | [ 2 | { 3 | "name": "batch-embedding", 4 | "prompt": "creates embeddings out of the numbers 1 to 10 (in text form)." 5 | } 6 | ] -------------------------------------------------------------------------------- /experiment/test-cases.json: -------------------------------------------------------------------------------- 1 | [ 2 | { 3 | "name": "hackernews", 4 | "prompt": "grab every sentence from hackernews frontpage and visualize them in a 2d umap using matplotlib" 5 | }, 6 | { 7 | "name": "image-rerank", 8 | "prompt": "I want to classify a series of images based on their domain, can I do that with Jina?" 9 | }, 10 | { 11 | "name": "batch-embedding", 12 | "prompt": "creates embeddings out of the numbers 1 to 100 (in text form)." 13 | }, 14 | { 15 | "name": "embedding for classification", 16 | "prompt": "generate an embedding that is good for a classification task for the word 'Jina'" 17 | }, 18 | { 19 | "name": "embedding late chunking", 20 | "prompt": "generate an embedding with late chunking for the word 'Jina'" 21 | }, 22 | { 23 | "name": "embedding binary return type", 24 | "prompt": "generate an embedding with binary return type for the word 'Jina'" 25 | }, 26 | { 27 | "name": "re-rank", 28 | "prompt": "re-ranks the words Jina, Weaviate, OpenAI, Hugging Face, Qdrant for the query 'Future of AI'." 29 | }, 30 | { 31 | "name": "reader-grounding", 32 | "prompt": "Write the js code to check the validity of the following statement on bbc.com 'The UK government has announced a new law that will require social media companies to verify the age of their users.'" 33 | }, 34 | { 35 | "name": "reader-grounding", 36 | "prompt": "i'd like to validate embedding api's visualization ability esp when output_dim=2, plz first select a \uD83E\uDD17 dataset around 1k data points in 2 classes, download it and use jina embedding api with task=separation; and visualize it in a scatter plot with square axis, 2 classes dots should be different color. and then do another one with output_dim=1024 and then do umap map to 2d and visualize it similariy, put these 2 plots sides by side. note that i run ur code in google colab." 37 | } 38 | ] -------------------------------------------------------------------------------- /experiment/test-cases/books.txt: -------------------------------------------------------------------------------- 1 | Search the Google Books API for each author in this list and return their latest 10 books, with no duplicates: 2 | 3 | - Terry Pratchett 4 | - William Shakespeare 5 | 6 | You can use this URL as an example: 7 | 8 | https://www.googleapis.com/books/v1/volumes?q=inauthor:%22Terry%20Pratchett%22&langRestrict=en&maxResults=30&printType=books&orderBy=newest 9 | 10 | That URL returns a response similar to: 11 | 12 | ```json 13 | { 14 | "items": [ 15 | { 16 | "volumeInfo": { 17 | "title": "The Illustrated Eric", 18 | "publishedDate": "2013-01-31", 19 | "description": "Terry Pratchett's hilarious take on the Faust legend stars many of the Discworld's most popular characters. Eric is the Discworld's only demonology hacker. The trouble is, he's not very good at it. All he wants is the usual three wishes: to be immortal, rule the world and have the most beautiful woman fall madly in love with him. The usual stuff. But what he gets is Rincewind, the Disc's most incompetent wizard, and Rincewind's Luggage (the world's most dangerous travel accessory) into the bargain. The outcome is an outrageous adventure that will leave Eric wishing once more - this time, quite fervently - that he'd never been born.", 20 | } 21 | } 22 | ] 23 | } 24 | ``` 25 | 26 | Write this information to a JSON list, with each entry having the keys: 27 | 28 | - author 29 | - title 30 | - published_date 31 | - description 32 | 33 | Classify each book as one of the following, and store under the key "genre": 34 | - Science-fiction 35 | - Fantasy 36 | - Non-fiction 37 | - Other 38 | 39 | Generate embedding for each book's description using jina-embeddings-v3 with passage task type and late chunking, and store under key `embedding`. 40 | 41 | Write all the data to books-embeddings.json. Write all the data (excluding embeddings) to books.json 42 | 43 | Provide logging via `rich` so I can see what's happening. Be verbose about logging any errors, for example, embeddings not being generated. 44 | 45 | Then present a search box for the user to type a query. encode that with the query task type then search through the books. Return the top ten matches, then use reranker to sort the results. Return the following: 46 | 47 | - Title 48 | - Description 49 | - Genre 50 | - Closeness to search term 51 | -------------------------------------------------------------------------------- /experiment/test-cases/docsqa.txt: -------------------------------------------------------------------------------- 1 | Create a simple RAG system using pages from these sources: 2 | 3 | - repo: https://github.com/jeff-dh/SolidPython 4 | - wiki: https://github.com/jeff-dh/SolidPython/wiki (and all the subpages) 5 | 6 | Scrape no other pages. 7 | 8 | Instead of using vector database, use JSON file 9 | 10 | You can access an LLM with the CLI command: 11 | 12 | ```shell 13 | llm 'your prompt' -m claude-3.5-sonnet 14 | ``` 15 | 16 | After segmenting and indexing all the pages, present a prompt for the user to ask a question. To answer the question, find the top three segments and pass them to the LLM with the prompt: 17 | 18 | ```text 19 | Based on these segments: 20 | 21 | - {segment 1} 22 | - {segment 2} 23 | - {segment 3} 24 | 25 | Answer the question: {question} 26 | ``` 27 | -------------------------------------------------------------------------------- /experiment/test-cases/papers.txt: -------------------------------------------------------------------------------- 1 | # Paper QA 2 | 3 | Create a Python script to: 4 | 5 | - Using Jina's Search API: Search arxiv.org for the 3 latest papers with the search term "embeddings". When you have found a paper, log its name. 6 | - Using Jina's Reader API: Scrape each paper's PDF and store the text and title 7 | - Using Jina's Segmenter API: Break the texts into segments 8 | - Using Jina's Embeddings API: Generate embeddings for each segment, using task_type retrieval.passage 9 | - Allow user to enter a search query to search through the papers, using task_type retrieval.query 10 | - Return each matching passage, along with the title of the paper. 11 | 12 | ## Notes 13 | 14 | - Provide some beautiful logging with rich so I can see what's happening. If an error arises, alert me. 15 | - Use the Jina API as described. Use no other libraries. 16 | -------------------------------------------------------------------------------- /experiment/test-cases/recipes.txt: -------------------------------------------------------------------------------- 1 | # Recipe Recommender 2 | 3 | Your job is to recommend recipes based on what I have available at home. You have access to an LLM with the shell command: `llm '' -m claude-3.5-sonnet` 4 | 5 | ## Instructions 6 | 7 | I have the following ingredients at home: 8 | 9 | - Onion 10 | - Chickpeas 11 | - Tinned chopped tomatoes 12 | - Chicken thighs (skin on, bone in) 13 | - EVOO 14 | - S+P 15 | - Herbs and spices: Cumin, garlic, ginger, italian seasoning, chilli flakes 16 | - Sweet potato 17 | - Peanut butter 18 | - Chicken stock 19 | - Milk 20 | - Sugar 21 | 22 | I have the following equipment: 23 | 24 | - Stove top 25 | - Pots and pans 26 | - Slow cooker 27 | - Various utensils 28 | 29 | 1. Use LLM to brainstorm recipe names from ingredients above 30 | 2. Search the internet for those recipes and retrieve each recipe page 31 | 3. Send that page to LLM to summarize the recipe into one paragraph 32 | 4. Rerank the summarized recipes by healthiness 33 | 5. Show the recipe name, summary and link to the website 34 | 35 | ## Notes 36 | 37 | - For dishes from specific countries, it's okay to search in those languages. 38 | - Try to avoid vegan or vegetarian dishes. 39 | - It's okay to have recipes that use just some of the ingredients, or recipes that need more ingredients than I currently have. 40 | - Provide some beautiful logging with a nice library so I can see what's happening. If an error arises, alert me. 41 | -------------------------------------------------------------------------------- /experiment/testResults/requirements.txt: -------------------------------------------------------------------------------- 1 | requests 2 | scikit-learn 3 | umap-learn 4 | matplotlib 5 | requests 6 | beautifulsoup4 7 | numpy 8 | umap-learn 9 | matplotlib 10 | nltk==3.8.1 11 | dotenv 12 | pandas 13 | seaborn -------------------------------------------------------------------------------- /experiment/testResults/v0/0-batch-embedding.py: -------------------------------------------------------------------------------- 1 | import os 2 | import requests 3 | 4 | # Read JINA API key from environment 5 | api_key = os.getenv("JINA_API_KEY") 6 | 7 | # Embed text with Jina AI Embeddings API 8 | texts = ["one", "two", "three", "four", "five", "six", "seven", "eight", "nine", "ten"] 9 | 10 | response = requests.post( 11 | "http://api.jina.ai/v1/embeddings", 12 | headers={ 13 | "Authorization": f"Bearer {api_key}", 14 | "Content-Type": "application/json", 15 | "accept": "application/json" 16 | }, 17 | json={ 18 | "model": "jina-embeddings-v3", 19 | "input": texts, 20 | "embedding_type": "float", 21 | "task": "retrieval.query" 22 | } 23 | ) 24 | 25 | if response.status_code == 200: 26 | embeddings = response.json()["data"] 27 | for embedding in embeddings: 28 | print(embedding["index"], embedding["embedding"]) 29 | else: 30 | print(f"Failed to create embeddings: {response.status_code}, {response.text}") -------------------------------------------------------------------------------- /experiment/testResults/v0/0-hackernews.py: -------------------------------------------------------------------------------- 1 | import os 2 | import requests 3 | import numpy as np 4 | import matplotlib.pyplot as plt 5 | import umap 6 | 7 | # Environment variable for API key 8 | API_KEY = os.getenv("JINA_API_KEY") 9 | 10 | # Fetching data from HACKERNEWS 11 | response = requests.get("https://hacker-news.firebaseio.com/v0/topstories.json?print=pretty") 12 | top_stories_ids = response.json()[:10] # Getting top 10 stories for example 13 | titles = [] 14 | 15 | for story_id in top_stories_ids: 16 | story_response = requests.get(f"https://hacker-news.firebaseio.com/v0/item/{story_id}.json?print=pretty") 17 | story_data = story_response.json() 18 | titles.append(story_data["title"]) 19 | 20 | # Preparing for embedding 21 | headers = { 22 | "Authorization": f"Bearer {API_KEY}", 23 | "Content-Type": "application/json", 24 | } 25 | data = { 26 | "model": "jina-embeddings-v3", 27 | "input": titles, 28 | "embedding_type": "float", 29 | } 30 | 31 | # Getting embeddings 32 | embed_response = requests.post("http://api.jina.ai/v1/embeddings", headers=headers, json=data) 33 | embeddings = np.array([item["embedding"] for item in embed_response.json()["data"]]) 34 | 35 | # Reduction with UMAP 36 | reducer = umap.UMAP(n_neighbors=5, min_dist=0.3, metric='correlation') 37 | embedding_2d = reducer.fit_transform(embeddings) 38 | 39 | # Plotting 40 | plt.figure(figsize=(12, 8)) 41 | plt.scatter(embedding_2d[:, 0], embedding_2d[:, 1]) 42 | for i, title in enumerate(titles): 43 | plt.text(embedding_2d[i, 0], embedding_2d[i, 1], title, fontsize=9) 44 | plt.title("UMAP projection of HackerNews Titles") 45 | plt.show() -------------------------------------------------------------------------------- /experiment/testResults/v0/1-image-rerank.py: -------------------------------------------------------------------------------- 1 | import os 2 | import requests 3 | 4 | JINA_API_KEY = os.getenv("JINA_API_KEY") 5 | 6 | headers = { 7 | "Authorization": f"Bearer {JINA_API_KEY}", 8 | "Content-Type": "application/json", 9 | } 10 | 11 | data = { 12 | "model": "jina-clip-v1", 13 | "input": ["image1_url", "image2_url", "image3_url"], 14 | "embedding_type": "float", 15 | "task": "classification", 16 | "dimensions": 768, 17 | } 18 | 19 | response = requests.post('http://api.jina.ai/v1/embeddings', headers=headers, json=data) 20 | print(response.json()) -------------------------------------------------------------------------------- /experiment/testResults/v0/10-docsqa.py: -------------------------------------------------------------------------------- 1 | import requests 2 | import os 3 | import json 4 | 5 | # Initialize variables 6 | JINA_API_KEY = os.getenv("JINA_API_KEY") 7 | HEADERS = {"Authorization": f"Bearer {JINA_API_KEY}"} 8 | JSON_FILE = "rag_system_data.json" 9 | 10 | # Function to extract and save data in JSON file 11 | def extract_save_data(): 12 | urls = ["https://github.com/jeff-dh/SolidPython", "https://github.com/jeff-dh/SolidPython/wiki"] 13 | all_data = [] 14 | 15 | for url in urls: 16 | response = requests.post("https://r.jina.ai/", headers=HEADERS, json={"url": url, "respondWith": "text"}) 17 | if response.status_code == 200: 18 | data = response.json()["data"] 19 | all_data.append(data) 20 | 21 | with open(JSON_FILE, 'w') as file: 22 | json.dump(all_data, file) 23 | 24 | # Extract and save data 25 | extract_save_data() 26 | 27 | def answer_question(question): 28 | # Load JSON data 29 | with open(JSON_FILE, 'r') as file: 30 | data = json.load(file) 31 | 32 | # Embed question 33 | embed_response = requests.post( 34 | "http://api.jina.ai/v1/embeddings", 35 | headers={"Authorization": f"Bearer {JINA_API_KEY}", "Content-Type": "application/json"}, 36 | json={"model": "jina-embeddings-v3", "input": [question], "task": "retrieval.query"} 37 | ) 38 | question_vector = embed_response.json()["data"][0]["embedding"] 39 | 40 | # Embed data paragraphs 41 | paragraphs = [para for sublist in data for para in sublist.split('\n\n')] 42 | embed_response = requests.post( 43 | "http://api.jina.ai/v1/embeddings", 44 | headers={"Authorization": f"Bearer {JINA_API_KEY}", "Content-Type": "application/json"}, 45 | json={"model": "jina-embeddings-v3", "input": paragraphs, "task": "retrieval.passage"} 46 | ) 47 | para_vectors = [x["embedding"] for x in embed_response.json()["data"]] 48 | 49 | # Find top 3 paragraphs 50 | similarities = [sum([a*b for a, b in zip(question_vector, para)]) for para in para_vectors] 51 | top_3_index = sorted(range(len(similarities)), key=lambda i: similarities[i], reverse=True)[:3] 52 | 53 | # Formulating prompt for the LLM 54 | top_3_segments = [paragraphs[i] for i in top_3_index] 55 | prompt = f"Based on these segments:\n\n- {top_3_segments[0]}\n- {top_3_segments[1]}\n- {top_3_segments[2]}\n\nAnswer the question: {question}" 56 | 57 | # Querying the LLM 58 | llm_response = requests.post( 59 | "http://llm.jina.ai/v1/predict", 60 | headers={"Authorization": f"Bearer {JINA_API_KEY}", "Content-Type": "application/json"}, 61 | json={"prompt": prompt, "model": "claude-3.5-sonnet"} 62 | ) 63 | 64 | # Print LLM response 65 | if llm_response.status_code == 200: 66 | print(llm_response.json()["data"][0]["generated_text"]) 67 | else: 68 | print("Error querying LLM") 69 | 70 | # Example usage 71 | question_prompt = input("Please ask a question related to the SolidPython project: ") 72 | answer_question(question_prompt) -------------------------------------------------------------------------------- /experiment/testResults/v0/11-papers.py: -------------------------------------------------------------------------------- 1 | import os 2 | import requests 3 | from rich.console import Console 4 | from rich.traceback import install 5 | from urllib.parse import urlencode 6 | 7 | install() 8 | console = Console() 9 | 10 | JINA_API_KEY = os.getenv("JINA_API_KEY") 11 | headers = {"Authorization": f"Bearer {JINA_API_KEY}"} 12 | 13 | def search_papers(query="embeddings", count=3): 14 | search_url = "https://s.jina.ai/" 15 | params = { 16 | "q": query, 17 | "count": count, 18 | "respondWith": "json" 19 | } 20 | try: 21 | response = requests.post(search_url, headers=headers, data=urlencode(params)) 22 | if response.status_code == 200: 23 | papers = response.json()["data"] 24 | console.log(f"Found {len(papers)} papers.") 25 | return [(paper["title"], paper["url"]) for paper in papers] 26 | else: 27 | console.log("Failed to search for papers", style="bold red") 28 | except Exception as e: 29 | console.log(f"Error during search: {str(e)}", style="bold red") 30 | 31 | def scrape_paper(url): 32 | reader_api = "https://r.jina.ai/" 33 | data = {"url": url} 34 | try: 35 | response = requests.post(reader_api, headers=headers, json=data) 36 | if response.status_code == 200: 37 | return response.json()["data"] 38 | else: 39 | console.log("Failed to scrape paper", style="bold red") 40 | except Exception as e: 41 | console.log(f"Error during scraping: {str(e)}", style="bold red") 42 | 43 | def segment_text(text): 44 | segment_api = "https://segment.jina.ai" 45 | try: 46 | response = requests.post(segment_api, headers=headers, json={"input": [text]}) 47 | if response.status_code == 200: 48 | return response.json()["chunks"] 49 | else: 50 | console.log("Failed to segment text", style="bold red") 51 | except Exception as e: 52 | console.log(f"Error during segmentation: {str(e)}", style="bold red") 53 | 54 | def generate_embeddings(texts, task_type="retrieval.passage"): 55 | embeddings_url = "https://api.jina.ai/v1/embeddings" 56 | data = { 57 | "model": "jina-embeddings-v3", 58 | "input": texts, 59 | "task": task_type 60 | } 61 | try: 62 | response = requests.post(embeddings_url, headers=headers, json=data) 63 | if response.status_code == 200: 64 | return response.json()["data"] 65 | else: 66 | console.log("Failed to generate embeddings", style="bold red") 67 | except Exception as e: 68 | console.log(f"Error generating embeddings: {str(e)}", style="bold red") 69 | 70 | def main(): 71 | query = input("Enter your search query: ") 72 | papers = search_papers() 73 | for title, url in papers: 74 | console.log(f"Processing paper: {title}") 75 | paper_text = scrape_paper(url) 76 | segments = segment_text(paper_text) 77 | embeddings = generate_embeddings(segments) 78 | query_embedding = generate_embeddings([query], task_type="retrieval.query")[0]["embedding"] 79 | matches = [] 80 | # Assuming cosine similarity function for simplicity, though it's not directly available here 81 | for segment, embedding in zip(segments, embeddings): 82 | # This part is simplified and demonstrates the concept, actual implementation of finding matches varies 83 | cos_sim = cosine_similarity(query_embedding, embedding["embedding"]) 84 | if cos_sim > 0.5: # A threshold for matching, for the demonstration purpose 85 | matches.append(segment) 86 | console.log(f"Matches in '{title}':") 87 | for match in matches: 88 | console.log(match) 89 | 90 | if __name__ == "__main__": 91 | main() -------------------------------------------------------------------------------- /experiment/testResults/v0/12-recipes.py: -------------------------------------------------------------------------------- 1 | import os 2 | import requests 3 | import logging 4 | 5 | # Setup logging 6 | logging.basicConfig(level=logging.INFO, format='%(asctime)s - %(levelname)s - %(message)s') 7 | 8 | JINA_API_KEY = os.getenv("JINA_API_KEY") 9 | HEADERS = {"Authorization": f"Bearer {JINA_API_KEY}"} 10 | 11 | def get_recipes(ingredients): 12 | """ 13 | Get a list of recipe names based on available ingredients. 14 | """ 15 | query = ", ".join(ingredients) 16 | response = requests.post( 17 | "https://s.jina.ai/", 18 | headers=HEADERS, 19 | json={"q": query, "count": 5, "respondWith": "json"} 20 | ) 21 | if response.status_code != 200: 22 | logging.error(f"Failed to search for recipes: {response.text}") 23 | return [] 24 | 25 | recipes = [result["title"] for result in response.json()["data"]] 26 | logging.info(f"Found recipes: {recipes}") 27 | return recipes 28 | 29 | def recipe_summaries(recipes): 30 | """ 31 | Retrieve summaries for each recipe. 32 | """ 33 | summaries = [] 34 | for recipe in recipes: 35 | response = requests.post( 36 | "https://r.jina.ai/", 37 | headers=HEADERS, 38 | json={"url": recipe["link"], "respondWith": "json"} 39 | ) 40 | if response.status_code != 200: 41 | logging.error(f"Failed to fetch recipe summary for {recipe['name']}: {response.text}") 42 | continue 43 | 44 | summary = response.json()["data"] 45 | summaries.append({"name": recipe["name"], "link": recipe["link"], "summary": summary}) 46 | 47 | return summaries 48 | 49 | def rerank_by_healthiness(summaries): 50 | """ 51 | Re-ranks recipes by healthiness. 52 | """ 53 | rerank_query = "healthiness" 54 | documents = [summary["summary"] for summary in summaries] 55 | 56 | response = requests.post( 57 | "https://api.jina.ai/v1/rerank", 58 | headers=HEADERS, 59 | json={"model": "jina-reranker-v2-base-multilingual", "query": rerank_query, "documents": documents, "top_n": len(documents), "return_documents": True} 60 | ) 61 | 62 | if response.status_code != 200: 63 | logging.error(f"Failed to rerank recipes: {response.text}") 64 | return [] 65 | 66 | reranked_summaries = response.json()["results"] 67 | sorted_summaries = [summaries[result["index"]] for result in reranked_summaries] 68 | return sorted_summaries 69 | 70 | def recommend_recipes(ingredients): 71 | """ 72 | Main function to recommend recipes. 73 | """ 74 | logging.info("Starting recipe recommendation process...") 75 | 76 | recipe_names = get_recipes(ingredients) 77 | if not recipe_names: 78 | logging.warning("No recipes found.") 79 | return 80 | 81 | summaries = recipe_summaries(recipe_names) 82 | if not summaries: 83 | logging.warning("No summaries available for the found recipes.") 84 | return 85 | 86 | reranked_summaries = rerank_by_healthiness(summaries) 87 | 88 | for recipe in reranked_summaries: 89 | print(f"Recipe Name: {recipe['name']}\nSummary: {recipe['summary']}\nLink: {recipe['link']}\n") 90 | 91 | # Example ingredients 92 | ingredients = [ 93 | "Onion", "Chickpeas", "Tinned chopped tomatoes", "Chicken thighs", 94 | "EVOO", "S+P", "Cumin", "Garlic", "Ginger", "Italian seasoning", 95 | "Chilli flakes", "Sweet potato", "Peanut butter", "Chicken stock", "Milk", "Sugar" 96 | ] 97 | 98 | try: 99 | recommend_recipes(ingredients) 100 | except Exception as e: 101 | logging.error(f"An error occurred: {str(e)}") -------------------------------------------------------------------------------- /experiment/testResults/v0/2-batch-embedding.py: -------------------------------------------------------------------------------- 1 | import os 2 | import requests 3 | 4 | # Gather API key from environment 5 | api_key = os.getenv('JINA_API_KEY') 6 | 7 | # Create the input data 8 | input_texts = [str(i) for i in range(1, 101)] # Create a list of numbers from 1 to 100 as strings 9 | 10 | # Define the API request parameters 11 | url = "http://api.jina.ai/v1/embeddings" 12 | headers = { 13 | "Authorization": f"Bearer {api_key}", 14 | "Content-Type": "application/json" 15 | } 16 | payload = { 17 | "model": "jina-embeddings-v3", 18 | "input": input_texts, 19 | "embedding_type": "float", 20 | "task": "retrieval.query", 21 | # Optional parameters can be added here based on requirements 22 | } 23 | 24 | # Make the request 25 | response = requests.post(url, json=payload, headers=headers) 26 | 27 | # Check response 28 | if response.status_code == 200: 29 | data = response.json() 30 | print("Embeddings generated successfully.") 31 | print(data) 32 | else: 33 | print(f"Failed to generate embeddings. Status code: {response.status_code}, Response message: {response.text}") -------------------------------------------------------------------------------- /experiment/testResults/v0/3-embedding for classification.py: -------------------------------------------------------------------------------- 1 | import os 2 | import requests 3 | 4 | # Reading the JINA_API_KEY from environment variable 5 | api_key = os.environ['JINA_API_KEY'] 6 | 7 | # Preparing the headers for the request 8 | headers = { 9 | 'Authorization': f'Bearer {api_key}', 10 | 'Content-Type': 'application/json', 11 | } 12 | 13 | # Preparing the data for the request 14 | data = { 15 | "model": "jina-embeddings-v3", 16 | "input": ["Jina"], 17 | "embedding_type": "float", 18 | "task": "classification", 19 | } 20 | 21 | # Making the POST request to the embeddings API 22 | response = requests.post('http://api.jina.ai/v1/embeddings', headers=headers, json=data) 23 | 24 | # Checking the response 25 | if response.status_code == 200: 26 | # Extracting the embeddings 27 | embeddings = response.json().get('data', []) 28 | print(embeddings) 29 | else: 30 | print("Error:", response.text) -------------------------------------------------------------------------------- /experiment/testResults/v0/4-embedding late chunking.py: -------------------------------------------------------------------------------- 1 | import os 2 | import requests 3 | 4 | # Read the API key from environment variable 5 | api_key = os.getenv("JINA_API_KEY") 6 | 7 | # Define the API endpoint 8 | url = "http://api.jina.ai/v1/embeddings" 9 | 10 | # Set the headers 11 | headers = { 12 | "Authorization": f"Bearer {api_key}", 13 | "Content-Type": "application/json", 14 | "accept": "application/json", 15 | } 16 | 17 | # Define the data payload 18 | data = { 19 | "model": "jina-embeddings-v3", 20 | "input": ["Jina"], 21 | "embedding_type": "float", 22 | "task": "retrieval.query", 23 | "dimensions": 768, 24 | "normalized": False, 25 | "late_chunking": True 26 | } 27 | 28 | # Make the POST request 29 | response = requests.post(url, json=data, headers=headers) 30 | 31 | # Print the response 32 | print(response.json()) -------------------------------------------------------------------------------- /experiment/testResults/v0/5-embedding binary return type.py: -------------------------------------------------------------------------------- 1 | import os 2 | import requests 3 | import json 4 | 5 | # Read API key from environment variable 6 | api_key = os.getenv('JINA_API_KEY') 7 | 8 | # Define the headers 9 | headers = { 10 | 'Authorization': f'Bearer {api_key}', 11 | 'Content-Type': 'application/json', 12 | 'accept': 'application/json' 13 | } 14 | 15 | # Define the request payload 16 | payload = { 17 | "model": "jina-embeddings-v3", 18 | "input": ["Jina"], 19 | "embedding_type": "binary" 20 | } 21 | 22 | # Make the HTTP POST request 23 | response = requests.post('http://api.jina.ai/v1/embeddings', headers=headers, data=json.dumps(payload)) 24 | 25 | # Print binary embedding 26 | print(response.json()) -------------------------------------------------------------------------------- /experiment/testResults/v0/6-re-rank.py: -------------------------------------------------------------------------------- 1 | import os 2 | import requests 3 | 4 | # Read the API key from environment variable 5 | jina_api_key = os.environ.get("JINA_API_KEY") 6 | 7 | # Input data for the Embedding API 8 | embedding_input = { 9 | "model": "jina-embeddings-v3", 10 | "input": ["Future of AI"], 11 | "task": "retrieval.query", 12 | } 13 | 14 | # Embedding API request 15 | embedding_response = requests.post( 16 | "http://api.jina.ai/v1/embeddings", 17 | headers={"Authorization": f"Bearer {jina_api_key}", "Content-Type": "application/json"}, 18 | json=embedding_input 19 | ) 20 | 21 | # Check if embedding request was successful 22 | if embedding_response.status_code == 200: 23 | embedding_data = embedding_response.json() 24 | # Assuming we get a vector for our query "Future of AI" 25 | query_vector = embedding_data["data"][0]["embedding"] 26 | 27 | # Input data for the Reranker API with documents representing each of the keywords 28 | reranker_input = { 29 | "model": "jina-reranker-v2-base-multilingual", 30 | "query": query_vector, 31 | "documents": ["Jina", "Weaviate", "OpenAI", "Hugging Face", "Qdrant"], 32 | } 33 | 34 | # Reranker API request 35 | reranker_response = requests.post( 36 | "http://api.jina.ai/v1/rerank", 37 | headers={"Authorization": f"Bearer {jina_api_key}", "Content-Type": "application/json"}, 38 | json=reranker_input 39 | ) 40 | 41 | # Process reranker response 42 | if reranker_response.status_code == 200: 43 | reranked_data = reranker_response.json() 44 | reranked_results = reranked_data["results"] 45 | # Print reranked documents 46 | for result in reranked_results: 47 | print(result["document"]["text"]) 48 | else: 49 | print("Error in reranking API request") 50 | else: 51 | print("Error in embedding API request") -------------------------------------------------------------------------------- /experiment/testResults/v0/7-reader-grounding.py: -------------------------------------------------------------------------------- 1 | import os 2 | import requests 3 | 4 | # Retrieve API key from environment variable 5 | api_key = os.getenv('JINA_API_KEY') 6 | 7 | def check_statement_validity(statement): 8 | # Grounding API request 9 | grounding_api_url = "https://g.jina.ai/" 10 | headers = { 11 | "Authorization": f"Bearer {api_key}", 12 | "Accept": "application/json" 13 | } 14 | data = { 15 | "q": "fact check query", 16 | "statement": statement 17 | } 18 | 19 | response = requests.post(grounding_api_url, headers=headers, json=data) 20 | if response.status_code == 200: 21 | result = response.json() 22 | if result["status"] == "success": 23 | fact_check_result = result["data"]["factCheckResult"] 24 | reason = result["data"]["reason"] 25 | sources = result["data"]["sources"] 26 | print(f"Fact Check Result: {fact_check_result}") 27 | print(f"Reason: {reason}") 28 | if sources: 29 | print("Sources:") 30 | for source in sources: 31 | print(source) 32 | else: 33 | print("Fact check failed.") 34 | else: 35 | print(f"API Error: {response.status_code}") 36 | 37 | # Example statement from bbc.com to verify 38 | statement_to_verify = "The UK government has announced a new law that will require social media companies to verify the age of their users." 39 | check_statement_validity(statement_to_verify) -------------------------------------------------------------------------------- /experiment/testResults/v0/8-reader-grounding.py: -------------------------------------------------------------------------------- 1 | import os 2 | import requests 3 | import matplotlib.pyplot as plt 4 | import seaborn as sns 5 | import pandas as pd 6 | from sklearn.decomposition import TruncatedSVD 7 | from umap import UMAP 8 | 9 | # Define Jina API key 10 | jina_api_key = os.environ["JINA_API_KEY"] 11 | 12 | # Download dataset 13 | dataset_url = "https://raw.githubusercontent.com/jbrownlee/Datasets/master/pima-indians-diabetes.data.csv" 14 | data = pd.read_csv(dataset_url, header=None).iloc[:1000, [0, 8]] # Selecting 1000 data points and 2 columns 15 | texts = data[0].apply(str).tolist() # Convert to list of texts 16 | labels = data[8].tolist() # Get labels for coloring 17 | 18 | # Embedding parameters 19 | headers = { 20 | "Authorization": f"Bearer {jina_api_key}", 21 | "Content-Type": "application/json", 22 | } 23 | data_2d = { 24 | "model": "jina-embeddings-v3", 25 | "input": texts, 26 | "task": "separation", 27 | "dimensions": 2, 28 | } 29 | data_1024d = { 30 | "model": "jina-embeddings-v3", 31 | "input": texts, 32 | "task": "separation", 33 | "dimensions": 1024, 34 | } 35 | 36 | # Embedding API request for 2D 37 | response_2d = requests.post("http://api.jina.ai/v1/embeddings", headers=headers, json=data_2d).json() 38 | 39 | # Extract embeddings and labels 40 | embeddings_2d = [d['embedding'] for d in response_2d['data']] 41 | 42 | # Embedding API request for 1024D 43 | response_1024d = requests.post("http://api.jina.ai/v1/embeddings", headers=headers, json=data_1024d).json() 44 | embeddings_1024d = [d['embedding'] for d in response_1024d['data']] 45 | 46 | # Reduce 1024D to 2D using UMAP 47 | umap = UMAP(n_components=2, random_state=42) 48 | embeddings_1024d_reduced = umap.fit_transform(embeddings_1024d) 49 | 50 | # Creating DataFrame for visualization 51 | df_2d = pd.DataFrame(embeddings_2d, columns=['Dim1', 'Dim2']) 52 | df_2d['Label'] = labels 53 | df_1024d = pd.DataFrame(embeddings_1024d_reduced, columns=['Dim1', 'Dim2']) 54 | df_1024d['Label'] = labels 55 | 56 | # Plotting 57 | fig, axs = plt.subplots(1, 2, figsize=(14, 7)) 58 | sns.scatterplot(data=df_2d, x='Dim1', y='Dim2', hue='Label', ax=axs[0], palette="viridis").set(title='2D Embeddings', aspect='equal') 59 | sns.scatterplot(data=df_1024d, x='Dim1', y='Dim2', hue='Label', ax=axs[1], palette="viridis").set(title='1024D reduced to 2D Embeddings', aspect='equal') 60 | plt.show() -------------------------------------------------------------------------------- /experiment/testResults/v0/9-books.py: -------------------------------------------------------------------------------- 1 | import os 2 | import requests 3 | from rich import console 4 | from rich.console import Console 5 | 6 | console = Console() 7 | 8 | jina_api_key = os.getenv("JINA_API_KEY") 9 | 10 | # Function to get embeddings for book descriptions 11 | def get_embeddings(descriptions): 12 | headers = { 13 | "Authorization": f"Bearer {jina_api_key}", 14 | "Content-Type": "application/json", 15 | } 16 | data = { 17 | "model": "jina-embeddings-v3", 18 | "input": descriptions, 19 | "task": "retrieval.passage", 20 | "late_chunking": True, 21 | } 22 | 23 | response = requests.post( 24 | "https://api.jina.ai/v1/embeddings", headers=headers, json=data 25 | ) 26 | 27 | if response.status_code == 200: 28 | return response.json()['data'] 29 | else: 30 | console.log(f"Error getting embeddings: {response.text}") 31 | return [] 32 | 33 | # Function to classify genres 34 | def classify_genres(descriptions): 35 | headers = { 36 | "Authorization": f"Bearer {jina_api_key}", 37 | "Content-Type": "application/json", 38 | } 39 | labels = ["Science-fiction", "Fantasy", "Non-fiction", "Other"] 40 | data = { 41 | "model": "jina-embeddings-v3", 42 | "input": [{"text": desc} for desc in descriptions], 43 | "labels": labels, 44 | } 45 | 46 | response = requests.post( 47 | "https://api.jina.ai/v1/classify", headers=headers, json=data 48 | ) 49 | 50 | if response.status_code == 200: 51 | return [item['prediction'] for item in response.json()['data']] 52 | else: 53 | console.log(f"Error classifying genres: {response.text}") 54 | return [] 55 | 56 | # Function to search and process books 57 | def search_books(authors): 58 | books_data = [] 59 | embeddings_data = [] 60 | for author in authors: 61 | # API Request 62 | url = f"https://www.googleapis.com/books/v1/volumes?q=inauthor:%22{author}%22&langRestrict=en&maxResults=40&printType=books&orderBy=newest" 63 | response = requests.get(url) 64 | if response.status_code == 200: 65 | items = response.json().get('items', []) 66 | descriptions = [] 67 | for item in items[:10]: # Limit to 10 latest books 68 | volume_info = item['volumeInfo'] 69 | title = volume_info.get('title', 'N/A') 70 | published_date = volume_info.get('publishedDate', 'N/A') 71 | description = volume_info.get('description', 'No description available.') 72 | 73 | # Temporary store description for embedding and classification 74 | descriptions.append(description) 75 | 76 | book_entry = { 77 | "author": author, 78 | "title": title, 79 | "published_date": published_date, 80 | "description": description, 81 | } 82 | books_data.append(book_entry) 83 | 84 | # Get genres and embeddings in bulk to reduce API calls 85 | genres = classify_genres(descriptions) 86 | embeddings = get_embeddings(descriptions) 87 | 88 | for i, book in enumerate(books_data[len(books_data)-len(items[:10]):]): 89 | book["genre"] = genres[i] 90 | book["embedding"] = embeddings[i]['embedding'] if i < len(embeddings) else [] 91 | 92 | # Separate data excluding embeddings for books.json 93 | embeddings_data.append({ 94 | **book, 95 | "embedding": book["embedding"] 96 | }) 97 | # Exclude embedding for books.json 98 | book.pop("embedding", None) 99 | 100 | console.log(f"Processed {author}'s books") 101 | else: 102 | console.log(f"Error fetching books for {author}: {response.text}") 103 | 104 | with open("books.json", "w") as bj: 105 | bj.write(json.dumps(books_data, indent=4)) 106 | 107 | with open("books-embeddings.json", "w") as be: 108 | be.write(json.dumps(embeddings_data, indent=4)) 109 | 110 | console.log("Books data saved!") 111 | 112 | # Search and interact 113 | def search_query(query): 114 | embeddings = get_embeddings([query])[0]['embedding'] if get_embeddings([query]) else None 115 | if embeddings: 116 | # Calculate closeness between query embedding and book embeddings 117 | closeness_scores = [] 118 | for book in embeddings_data: 119 | book_embedding = book['embedding'] 120 | score = 1 - spatial.distance.cosine(embeddings, book_embedding) # Example calculation, replace with actual 121 | closeness_scores.append((book, score)) 122 | 123 | # Sort based on closeness 124 | sorted_books = sorted(closeness_scores, key=lambda x: x[1], reverse=True)[:10] 125 | 126 | # Rerank the sorted books 127 | reranked_books = rerank_books(query, [book[0]['title'] for book in sorted_books]) 128 | return reranked_books 129 | else: 130 | console.log("Error generating query embeddings") 131 | return [] 132 | 133 | def rerank_books(query, documents): 134 | headers = { 135 | "Authorization": f"Bearer {jina_api_key}", 136 | "Content-Type": "application/json", 137 | } 138 | data = { 139 | "model": "jina-reranker-v2-base-multilingual", 140 | "query": query, 141 | "documents": documents, 142 | "top_n": len(documents), 143 | "return_documents": True, 144 | } 145 | 146 | response = requests.post("https://api.jina.ai/v1/rerank", headers=headers, json=data) 147 | 148 | if response.status_code == 200: 149 | return response.json()['results'] 150 | else: 151 | console.log(f"Error reranking: {response.text}") 152 | return [] 153 | 154 | search_books(["Terry Pratchett", "William Shakespeare"]) 155 | # Later, use search_query("your search term") to search through the processed books. -------------------------------------------------------------------------------- /experiment/testResults/v1/0-batch-embedding.py: -------------------------------------------------------------------------------- 1 | import os 2 | import requests 3 | import json 4 | 5 | JINA_API_KEY = os.getenv("JINA_API_KEY") 6 | 7 | def embed_texts(texts, model="jina-embeddings-v3"): 8 | headers = { 9 | "Authorization": f"Bearer {JINA_API_KEY}", 10 | "Content-Type": "application/json" 11 | } 12 | payload = { 13 | "model": model, 14 | "input": texts 15 | } 16 | try: 17 | response = requests.post("https://api.jina.ai/v1/embeddings", headers=headers, data=json.dumps(payload)) 18 | if response.status_code == 200: 19 | return response.json()["data"] 20 | else: 21 | return {"error": "Failed to get embeddings", "status_code": response.status_code} 22 | except requests.exceptions.RequestException as e: 23 | return {"error": str(e)} 24 | 25 | def main(): 26 | texts_to_embed = ["one", "two", "three", "four", "five", "six", "seven", "eight", "nine", "ten"] 27 | embeddings = embed_texts(texts_to_embed) 28 | 29 | if "error" in embeddings: 30 | print(embeddings["error"]) 31 | else: 32 | print(embeddings) 33 | 34 | if __name__ == "__main__": 35 | main() -------------------------------------------------------------------------------- /experiment/testResults/v1/0-hackernews.py: -------------------------------------------------------------------------------- 1 | import os 2 | import requests 3 | import matplotlib.pyplot as plt 4 | import umap 5 | import numpy as np 6 | from dotenv import load_dotenv 7 | 8 | load_dotenv() 9 | JINA_API_KEY = os.getenv('JINA_API_KEY') 10 | 11 | def get_hackernews_headlines(): 12 | response = requests.get('https://hacker-news.firebaseio.com/v0/topstories.json?print=pretty') 13 | top_stories_ids = response.json() 14 | headlines = [] 15 | for story_id in top_stories_ids[:30]: # Limit to top 30 stories for brevity 16 | story_response = requests.get(f'https://hacker-news.firebaseio.com/v0/item/{story_id}.json?print=pretty') 17 | story_data = story_response.json() 18 | headlines.append(story_data['title']) 19 | return headlines 20 | 21 | def embed_texts(texts): 22 | headers = { 23 | 'Authorization': f'Bearer {JINA_API_KEY}', 24 | } 25 | data = { 26 | 'model': 'jina-embeddings-v3', 27 | 'input': texts, 28 | } 29 | response = requests.post('https://api.jina.ai/v1/embeddings', headers=headers, json=data) 30 | embeddings = response.json() 31 | return [item['embedding_vector'] for item in embeddings['data']] 32 | 33 | def visualize_embeddings(embeddings): 34 | reducer = umap.UMAP() 35 | embedding_coords = reducer.fit_transform(embeddings) 36 | 37 | plt.figure(figsize=(10, 10)) 38 | plt.scatter(embedding_coords[:, 0], embedding_coords[:, 1]) 39 | plt.title('UMAP visualization of HackerNews Headlines') 40 | plt.show() 41 | 42 | def main(): 43 | headlines = get_hackernews_headlines() 44 | embeddings = embed_texts(headlines) 45 | # Convert embeddings from strings to np.arrays 46 | embeddings_np = np.array([np.fromstring(embedding, sep=',') for embedding in embeddings]) 47 | visualize_embeddings(embeddings_np) 48 | 49 | if __name__ == '__main__': 50 | main() -------------------------------------------------------------------------------- /experiment/testResults/v1/1-image-rerank.py: -------------------------------------------------------------------------------- 1 | import os 2 | import requests 3 | 4 | # Read Jina API key from environment variable 5 | JINA_API_KEY = os.getenv('JINA_API_KEY') 6 | auth_headers = {'Authorization': f'Bearer {JINA_API_KEY}'} 7 | 8 | def classify_images(images, labels): 9 | """ 10 | Classify images based on the given labels using Jina Classifier API. 11 | :param images: List of base64-encoded image strings. 12 | :param labels: List of labels for classification. 13 | :return: Classification results. 14 | """ 15 | classify_endpoint = "https://api.jina.ai/v1/classify" 16 | payload = { 17 | "model": "jina-clip-v1", 18 | "input": [{"image": img} for img in images], 19 | "labels": labels 20 | } 21 | try: 22 | response = requests.post(classify_endpoint, json=payload, headers=auth_headers) 23 | response.raise_for_status() 24 | return response.json() 25 | except requests.exceptions.HTTPError as err: 26 | return str(err) 27 | except Exception as e: 28 | return str(e) 29 | 30 | def main(): 31 | # Example images and labels 32 | images = ["base64_image_string1", "base64_image_string2"] # Replace with actual base64-encoded image strings 33 | labels = ["domain1", "domain2", "domain3"] # Replace with your actual labels 34 | 35 | # Classify Images 36 | classification_results = classify_images(images, labels) 37 | print(classification_results) 38 | 39 | if __name__ == "__main__": 40 | main() -------------------------------------------------------------------------------- /experiment/testResults/v1/10-docsqa.py: -------------------------------------------------------------------------------- 1 | import os 2 | import requests 3 | import json 4 | 5 | JINA_API_KEY = os.getenv('JINA_API_KEY') 6 | 7 | def embed(texts): 8 | try: 9 | headers = { 10 | 'Authorization': f'Bearer {JINA_API_KEY}', 11 | 'Content-Type': 'application/json', 12 | 'Accept': 'application/json' 13 | } 14 | data = { 15 | 'model': 'jina-embeddings-v3', 16 | 'input': texts 17 | } 18 | response = requests.post('https://api.jina.ai/v1/embeddings', headers=headers, json=data) 19 | response.raise_for_status() 20 | return response.json() 21 | except requests.RequestException as e: 22 | print(f'An error occurred: {e}') 23 | 24 | def rerank(query, documents): 25 | try: 26 | headers = { 27 | 'Authorization': f'Bearer {JINA_API_KEY}', 28 | 'Content-Type': 'application/json', 29 | 'Accept': 'application/json' 30 | } 31 | data = { 32 | 'model': 'jina-reranker-v2-base-multilingual', 33 | 'query': query, 34 | 'documents': documents 35 | } 36 | response = requests.post('https://api.jina.ai/v1/rerank', headers=headers, json=data) 37 | response.raise_for_status() 38 | return response.json() 39 | except requests.RequestException as e: 40 | print(f'An error occurred: {e}') 41 | 42 | def classify(images, labels): 43 | try: 44 | headers = { 45 | 'Authorization': f'Bearer {JINA_API_KEY}', 46 | 'Content-Type': 'application/json', 47 | 'Accept': 'application/json' 48 | } 49 | data = { 50 | 'model': 'jina-clip-v1', 51 | 'input': [{'image': image} for image in images], 52 | 'labels': labels 53 | } 54 | response = requests.post('https://api.jina.ai/v1/classify', headers=headers, json=data) 55 | response.raise_for_status() 56 | return response.json() 57 | except requests.RequestException as e: 58 | print(f'An error occurred: {e}') 59 | 60 | def read(url): 61 | try: 62 | headers = { 63 | 'Authorization': f'Bearer {JINA_API_KEY}', 64 | 'Content-Type': 'application/json', 65 | 'Accept': 'application/json', 66 | 'X-No-Cache': 'true' 67 | } 68 | data = { 69 | 'url': url, 70 | 'options': 'Default' 71 | } 72 | response = requests.post('https://r.jina.ai/', headers=headers, json=data) 73 | response.raise_for_status() 74 | return response.json() 75 | except requests.RequestException as e: 76 | print(f'An error occurred: {e}') 77 | 78 | def main(): 79 | # Example usage of embed API 80 | texts = ["Hello, world!", "How can I use Jina AI's APIs?"] 81 | embeddings_response = embed(texts) 82 | print(embeddings_response) 83 | 84 | # Example usage of classify API 85 | images = ['base64_image_string'] 86 | labels = ['positive', 'negative'] 87 | classification_response = classify(images, labels) 88 | print(classification_response) 89 | 90 | # Example usage of read API 91 | page_content = read('https://github.com/jeff-dh/SolidPython') 92 | print(page_content) 93 | 94 | if __name__ == "__main__": 95 | main() -------------------------------------------------------------------------------- /experiment/testResults/v1/11-papers.py: -------------------------------------------------------------------------------- 1 | import os 2 | import requests 3 | from rich.console import Console 4 | from rich.logging import RichHandler 5 | import logging 6 | 7 | # Setup rich logging 8 | logging.basicConfig(level="INFO", format="%(message)s", datefmt="[%X]", handlers=[RichHandler()]) 9 | logger = logging.getLogger("rich") 10 | 11 | # Jina API Key 12 | JINA_API_KEY = os.getenv("JINA_API_KEY") 13 | if not JINA_API_KEY: 14 | logger.error("JINA_API_KEY environment variable not set. Please set it before running this code.") 15 | exit(1) 16 | 17 | # Headers for API requests 18 | headers = { 19 | "Authorization": f"Bearer {JINA_API_KEY}", 20 | "Content-Type": "application/json", 21 | "Accept": "application/json", 22 | } 23 | 24 | 25 | def search_papers(search_term): 26 | """Search for the latest papers with the search term""" 27 | url = "https://s.jina.ai/" 28 | payload = { 29 | "q": search_term, 30 | "options": "Default" 31 | } 32 | 33 | try: 34 | response = requests.post(url, json=payload, headers=headers) 35 | response.raise_for_status() 36 | papers = response.json()["data"][:3] # Get the top 3 papers 37 | logger.info("Successfully found papers based on the term.") 38 | return [(paper["title"], paper["url"]) for paper in papers] 39 | except Exception as e: 40 | logger.error(f"Error searching for papers: {e}") 41 | return [] 42 | 43 | 44 | def read_content(url): 45 | """Read contents of a paper using the Reader API""" 46 | read_url = "https://r.jina.ai/" 47 | payload = { 48 | "url": url 49 | } 50 | 51 | try: 52 | response = requests.post(read_url, json=payload, headers=headers) 53 | response.raise_for_status() 54 | content = response.json()["data"]["content"] 55 | logger.info("Successfully read the paper content.") 56 | return content 57 | except Exception as e: 58 | logger.error(f"Error reading content from {url}: {e}") 59 | return "" 60 | 61 | 62 | def generate_embeddings(text_segments, task_type="retrieval.passage"): 63 | """Generate embeddings for each text segment""" 64 | url = "https://api.jina.ai/v1/embeddings" 65 | payload = { 66 | "model": "jina-embeddings-v3", 67 | "input": text_segments, 68 | "task": task_type, 69 | } 70 | 71 | try: 72 | response = requests.post(url, json=payload, headers=headers) 73 | response.raise_for_status() 74 | embeddings = response.json()["data"] 75 | logger.info("Successfully generated embeddings.") 76 | return embeddings 77 | except Exception as e: 78 | logger.error(f"Error generating embeddings: {e}") 79 | return [] 80 | 81 | 82 | def search_in_paper(segments, query): 83 | """Search a query within the paper's segments""" 84 | embeddings = generate_embeddings([query] + segments, task_type="retrieval.query") 85 | query_embedding = embeddings[0]['embedding_vector'] 86 | segment_embeddings = embeddings[1:] 87 | scores = [(index, cosine_similarity(query_embedding, segment['embedding_vector'])) for index, segment in enumerate(segment_embeddings)] 88 | scores.sort(key=lambda x: x[1], reverse=True) # Sort by score highest to lowest 89 | top_matches = scores[:3] # Top 3 matches 90 | logger.info("Successfully searched within the paper.") 91 | return [segments[index] for index, score in top_matches] 92 | 93 | 94 | def cosine_similarity(vec1, vec2): 95 | """Calculate the cosine similarity between two vectors""" 96 | dot_product = sum(p*q for p,q in zip(vec1, vec2)) 97 | magnitude = lambda vec: sum(x**2 for x in vec) ** .5 98 | return dot_product / (magnitude(vec1) * magnitude(vec2)) 99 | 100 | 101 | def main(): 102 | search_term = "embeddings" 103 | papers = search_papers(search_term) 104 | 105 | for title, url in papers: 106 | logger.info(f"Reading {title}") 107 | content = read_content(url) 108 | segments = [content[i:i+512] for i in range(0, len(content), 512)] # Simple segmentation 109 | embeddings = generate_embeddings(segments) 110 | logger.info(f"Generated embeddings for segments in {title}") 111 | 112 | # Assuming a user query for demonstration purposes 113 | user_query = "deep learning" 114 | matching_segments = search_in_paper(segments, user_query) 115 | 116 | logger.info(f"Matching segments for '{user_query}':") 117 | for segment in matching_segments: 118 | logger.info(f"Segment: {segment[:200]}...") # Show a snippet 119 | 120 | 121 | if __name__ == "__main__": 122 | main() -------------------------------------------------------------------------------- /experiment/testResults/v1/12-recipes.py: -------------------------------------------------------------------------------- 1 | import os 2 | import requests 3 | import logging 4 | from dotenv import load_dotenv 5 | 6 | # Load environment variables 7 | load_dotenv() 8 | JINA_API_KEY = os.getenv("JINA_API_KEY") 9 | 10 | # Set up logging 11 | logging.basicConfig(level=logging.INFO, format='%(asctime)s - %(levelname)s - %(message)s') 12 | 13 | # Headers for API requests 14 | API_HEADERS = { 15 | "Authorization": f"Bearer {JINA_API_KEY}", 16 | "Content-Type": "application/json" 17 | } 18 | 19 | # Function to perform web search 20 | def search(query): 21 | try: 22 | response = requests.post( 23 | 'https://s.jina.ai/', 24 | headers=API_HEADERS, 25 | json={"q": query, "options": "Default"} 26 | ) 27 | response.raise_for_status() 28 | search_results = response.json()["data"] 29 | logging.info("Web search successful.") 30 | return search_results 31 | except Exception as e: 32 | logging.error(f"Web search failed: {e}") 33 | return [] 34 | 35 | # Function to summarize a webpage content 36 | def summarize(url): 37 | try: 38 | response = requests.post( 39 | 'https://r.jina.ai/', 40 | headers={**API_HEADERS, "X-No-Cache": "true"}, 41 | json={"url": url} 42 | ) 43 | response.raise_for_status() 44 | content = response.json()["data"]["content"] 45 | logging.info("Webpage summarization successful.") 46 | return content 47 | except Exception as e: 48 | logging.error(f"Webpage summarization failed: {e}") 49 | return "" 50 | 51 | # Main execution function 52 | def main(): 53 | recipes_queries = [ 54 | "chicken thighs with chickpeas recipe", 55 | "sweet potato peanut butter stew recipe", 56 | "spicy chicken with tinned tomatoes recipe" 57 | ] 58 | 59 | # Search for recipes 60 | all_search_results = [] 61 | for query in recipes_queries: 62 | search_results = search(query) 63 | if search_results: 64 | for result in search_results: 65 | all_search_results.append({"title": result["title"], "url": result["url"]}) 66 | 67 | if not all_search_results: 68 | logging.info("No recipes found matching the criteria.") 69 | return 70 | 71 | # Summarize the content of the recipe pages 72 | recipes_summaries = [] 73 | for result in all_search_results: 74 | summary = summarize(result["url"]) 75 | if summary: 76 | recipes_summaries.append({"title": result["title"], "summary": summary, "url": result["url"]}) 77 | 78 | # Since we can't directly rank by healthiness without further data, 79 | # we encourage users to review the summaries and pick based on their dietary preferences. 80 | for recipe in recipes_summaries: 81 | print(f"Recipe Name: {recipe['title']}\nSummary:\n{recipe['summary']}\nLink: {recipe['url']}\n\n") 82 | 83 | if __name__ == "__main__": 84 | main() -------------------------------------------------------------------------------- /experiment/testResults/v1/2-batch-embedding.py: -------------------------------------------------------------------------------- 1 | import os 2 | import requests 3 | import json 4 | 5 | # Reading the Jina API key from environment variable 6 | JINA_API_KEY = os.environ.get("JINA_API_KEY") 7 | 8 | # Function to generate embeddings for text inputs 9 | def generate_embeddings(model: str, inputs: list, embedding_type="float"): 10 | url = "https://api.jina.ai/v1/embeddings" 11 | headers = { 12 | "Authorization": f"Bearer {JINA_API_KEY}", 13 | "Content-Type": "application/json" 14 | } 15 | data = { 16 | "model": model, 17 | "input": inputs, 18 | "embedding_type": embedding_type 19 | } 20 | 21 | try: 22 | response = requests.post(url, headers=headers, data=json.dumps(data)) 23 | if response.status_code == 200: 24 | return response.json() # If successful, return the JSON response 25 | else: 26 | return {"error": "Failed to generate embeddings", "status_code": response.status_code} 27 | except Exception as e: 28 | return {"error": str(e)} 29 | 30 | # Main function to process list of numbers 31 | def main(): 32 | numbers_text = [str(i) for i in range(1, 101)] # Converting numbers 1 to 100 into text 33 | model = "jina-embeddings-v3" # Using the model jina-embeddings-v3 for embeddings 34 | embeddings_response = generate_embeddings(model, numbers_text) 35 | 36 | if "error" not in embeddings_response: 37 | print("Embeddings generated successfully.") 38 | # Do something with embeddings_response, like saving or further processing 39 | print(embeddings_response) # For demonstration, printing the response 40 | else: 41 | print("Error:", embeddings_response.get("error"), "Status Code:", embeddings_response.get("status_code")) 42 | 43 | # Execute the main function 44 | if __name__ == "__main__": 45 | main() -------------------------------------------------------------------------------- /experiment/testResults/v1/3-embedding for classification.py: -------------------------------------------------------------------------------- 1 | import os 2 | import requests 3 | 4 | def generate_embedding(text): 5 | api_key = os.getenv("JINA_API_KEY") 6 | headers = { 7 | "Authorization": f"Bearer {api_key}", 8 | "Content-Type": "application/json" 9 | } 10 | payload = { 11 | "model": "jina-embeddings-v3", 12 | "input": [text], 13 | "task": "classification" 14 | } 15 | try: 16 | response = requests.post("https://api.jina.ai/v1/embeddings", json=payload, headers=headers) 17 | response.raise_for_status() 18 | embeddings = response.json() 19 | return embeddings.get("data")[0].get("embedding_vector") 20 | except requests.exceptions.RequestException as e: 21 | print(f"Request failed: {e}") 22 | 23 | embedding_vector = generate_embedding("Jina") 24 | print(embedding_vector) -------------------------------------------------------------------------------- /experiment/testResults/v1/4-embedding late chunking.py: -------------------------------------------------------------------------------- 1 | import os 2 | import requests 3 | 4 | def generate_embedding(input_text, late_chunking=True): 5 | token = os.getenv("JINA_API_KEY") 6 | headers = { 7 | "Authorization": f"Bearer {token}", 8 | "Content-Type": "application/json" 9 | } 10 | payload = { 11 | "model": "jina-embeddings-v3", 12 | "input": [input_text], 13 | "late_chunking": late_chunking 14 | } 15 | try: 16 | response = requests.post("https://api.jina.ai/v1/embeddings", json=payload, headers=headers) 17 | response.raise_for_status() 18 | return response.json() 19 | except requests.exceptions.HTTPError as err: 20 | return f"HTTP error: {err}" 21 | except Exception as err: 22 | return f"Error: {err}" 23 | 24 | # Example usage: 25 | embedding_result = generate_embedding("Jina") 26 | print(embedding_result) -------------------------------------------------------------------------------- /experiment/testResults/v1/5-embedding binary return type.py: -------------------------------------------------------------------------------- 1 | import os 2 | import requests 3 | 4 | def generate_embedding(text, return_type='binary'): 5 | api_key = os.getenv('JINA_API_KEY') 6 | headers = {"Authorization": f"Bearer {api_key}"} 7 | payload = { 8 | "model": "jina-embeddings-v3", 9 | "input": [text], 10 | "embedding_type": return_type 11 | } 12 | 13 | response = requests.post("https://api.jina.ai/v1/embeddings", json=payload, headers=headers) 14 | if response.status_code == 200: 15 | return response.json()['data'][0]['embedding_vector'] 16 | else: 17 | return "Error: " + response.json()['error']['message'] 18 | 19 | # Example usage: 20 | embedding_vector = generate_embedding("Jina", "binary") 21 | print(embedding_vector) -------------------------------------------------------------------------------- /experiment/testResults/v1/6-re-rank.py: -------------------------------------------------------------------------------- 1 | import os 2 | import requests 3 | import json 4 | 5 | # Get the JINA_API_KEY from environment variable 6 | JINA_API_KEY = os.environ.get("JINA_API_KEY") 7 | 8 | # Function to call the Embeddings API and get embeddings for the input texts 9 | def get_embeddings(texts): 10 | headers = { 11 | 'Authorization': f'Bearer {JINA_API_KEY}', 12 | 'Content-Type': 'application/json' 13 | } 14 | data = { 15 | "model": "jina-embeddings-v3", 16 | "input": texts, 17 | } 18 | response = requests.post('https://api.jina.ai/v1/embeddings', headers=headers, data=json.dumps(data)) 19 | try: 20 | embeddings = response.json() 21 | return embeddings['data'] 22 | except Exception as e: 23 | print(f"Error getting embeddings: {str(e)}") 24 | return None 25 | 26 | # Function to call the Reranker API to rerank a list of documents based on a query 27 | def rerank_documents(query, documents): 28 | headers = { 29 | 'Authorization': f'Bearer {JINA_API_KEY}', 30 | 'Content-Type': 'application/json' 31 | } 32 | data = { 33 | "model": "jina-reranker-v2-base-multilingual", 34 | "query": query, 35 | "documents": documents, 36 | } 37 | response = requests.post('https://api.jina.ai/v1/rerank', headers=headers, data=json.dumps(data)) 38 | try: 39 | reranked_docs = response.json() 40 | return reranked_docs['results'] 41 | except Exception as e: 42 | print(f"Error reranking documents: {str(e)}") 43 | return None 44 | 45 | # Main function to execute the re-ranking for the provided query and documents 46 | def main(): 47 | query = "Future of AI" 48 | documents = ["Jina", "Weaviate", "OpenAI", "Hugging Face", "Qdrant"] 49 | embeddings = get_embeddings([query] + documents) 50 | if embeddings: 51 | # Assuming we are re-ranking based on the similarity of their embeddings, 52 | # a simple workaround since direct reranking by embeddings is not shown 53 | query_embedding = embeddings[0]['embedding_vector'] 54 | document_embeddings = embeddings[1:] 55 | document_scores = [] 56 | for idx, doc_emb in enumerate(document_embeddings): 57 | # Just a placeholder for actual similarity calculation which is not detailed here 58 | similarity_score = sum([q * d for q, d in zip(query_embedding, doc_emb['embedding_vector'])]) 59 | document_scores.append((documents[idx], similarity_score)) 60 | 61 | sorted_docs = sorted(document_scores, key=lambda x: x[1], reverse=True) 62 | print(f"Documents ranked by future relevance to AI: {sorted_docs}") 63 | else: 64 | print("Could not retrieve embeddings to rerank documents.") 65 | 66 | if __name__ == "__main__": 67 | main() -------------------------------------------------------------------------------- /experiment/testResults/v1/7-reader-grounding.py: -------------------------------------------------------------------------------- 1 | import os 2 | import requests 3 | 4 | # Read environment variable for API key 5 | JINA_API_KEY = os.getenv('JINA_API_KEY') 6 | 7 | # Headers for authentication 8 | headers = { 9 | "Authorization": f"Bearer {JINA_API_KEY}", 10 | "Content-Type": "application/json", 11 | "Accept": "application/json", 12 | } 13 | 14 | def read_bbc_content(url): 15 | """ 16 | Reads the content of a BBC article URL using Jina AI's Reader API 17 | """ 18 | reader_api_url = "https://r.jina.ai/" 19 | payload = { 20 | "url": url, 21 | "options": "Default" 22 | } 23 | 24 | try: 25 | response = requests.post(reader_api_url, headers=headers, json=payload) 26 | response.raise_for_status() 27 | data = response.json() 28 | return data.get("data", {}).get("content", "") 29 | except requests.RequestException as e: 30 | print(f"Error fetching URL content: {e}") 31 | return "" 32 | 33 | def check_statement_validity(statement, content): 34 | """ 35 | Checks if a given statement is valid within the provided content using Jina AI's Embeddings API 36 | """ 37 | embeddings_api_url = "https://api.jina.ai/v1/embeddings" 38 | payload = { 39 | "model": "jina-embeddings-v3", 40 | "input": [statement, content], 41 | "embedding_type": "float", 42 | "task": "text-matching" 43 | } 44 | 45 | try: 46 | response = requests.post(embeddings_api_url, headers=headers, json=payload) 47 | response.raise_for_status() 48 | embeddings = response.json().get("data", []) 49 | # Here a more sophisticated similarity check could be performed 50 | # For simplicity, we just outline hypothetical embedding comparison. 51 | print("Embeddings obtained. Compare embeddings for validation.") 52 | except requests.RequestException as e: 53 | print(f"Error generating embeddings: {e}") 54 | 55 | def main(): 56 | bbc_url = "https://www.bbc.com/news/technology" 57 | statement = "The UK government has announced a new law that will require social media companies to verify the age of their users." 58 | 59 | # Step 1: Read content from BBC URL 60 | content = read_bbc_content(bbc_url) 61 | if content: 62 | print("Content fetched. Checking statement...") 63 | # Step 2: Verify the statement using embeddings 64 | check_statement_validity(statement, content) 65 | else: 66 | print("Failed to fetch content.") 67 | 68 | # Run the main function 69 | if __name__ == "__main__": 70 | main() -------------------------------------------------------------------------------- /experiment/testResults/v1/8-reader-grounding.py: -------------------------------------------------------------------------------- 1 | import os 2 | import requests 3 | import matplotlib.pyplot as plt 4 | import pandas as pd 5 | import numpy as np 6 | from sklearn.datasets import make_classification 7 | from sklearn.manifold import TSNE 8 | import umap.umap_ as umap 9 | 10 | # Set API key 11 | JINA_API_KEY = os.getenv("JINA_API_KEY") 12 | headers = {"Authorization": f"Bearer {JINA_API_KEY}"} 13 | 14 | # Generate synthetic data 15 | X, y = make_classification(n_samples=1000, n_features=20, n_informative=2, n_redundant=10, n_clusters_per_class=1, n_classes=2) 16 | 17 | # Convert to list for API 18 | data = X.tolist() 19 | 20 | # Embedding function 21 | def get_embeddings(data, output_dim): 22 | response = requests.post("https://api.jina.ai/v1/embeddings", 23 | json={"model": "jina-embeddings-v3", "input": data, "task": "separation", 24 | "dimensions": output_dim}, 25 | headers=headers) 26 | if response.status_code == 200: 27 | return [datum['embedding_vector'] for datum in response.json()['data']] 28 | else: 29 | raise ValueError("Failed to get embeddings") 30 | 31 | # Function to plot embeddings 32 | def plot_embeddings(embeddings, labels, title, ax): 33 | df = pd.DataFrame(data=embeddings) 34 | df['label'] = labels 35 | colors = {0: 'red', 1: 'blue'} 36 | df.plot.scatter(x=0, y=1, c=df['label'].map(colors), ax=ax, title=title, xlabel='Dimension 1', ylabel='Dimension 2', xlim=(-10,10), ylim=(-10,10)) 37 | 38 | # Get embeddings with 2 dimensions 39 | embeddings_2d = get_embeddings(data, 2) 40 | 41 | # UMAP reduction to 2 dimensions from 1024 dimensions embedding 42 | embeddings_1024d = get_embeddings(data, 1024) 43 | reducer = umap.UMAP(n_components=2) 44 | umap_embeddings = reducer.fit_transform(np.array(embeddings_1024d)) 45 | 46 | # Plotting 47 | fig, axs = plt.subplots(1, 2, figsize=(14, 7)) 48 | plot_embeddings(embeddings_2d, y, '2D Embeddings', axs[0]) 49 | plot_embeddings(umap_embeddings, y, 'UMAP reduced 1024D to 2D Embeddings', axs[1]) 50 | 51 | plt.show() -------------------------------------------------------------------------------- /experiment/testResults/v1/9-books.py: -------------------------------------------------------------------------------- 1 | I'm unable to execute or simulate live API calls, including those to Jina AI's services, or directly generate, modify, or manage external files or databases from this platform. However, I can provide you with a detailed Python script that shows how to achieve the tasks you described, using Jina AI Search Foundation APIs, including handling embedding generation, classification, and search functionalities. Remember to replace `"YOUR_JINA_API_KEY"` with your actual Jina API key. 2 | 3 | ```python 4 | import requests 5 | import json 6 | import os 7 | from rich import console 8 | 9 | console = console.Console() 10 | 11 | JINA_API_KEY = os.getenv("JINA_API_KEY") 12 | headers = {"Authorization": f"Bearer {JINA_API_KEY}"} 13 | 14 | def get_book_info(author): 15 | url = f"https://www.googleapis.com/books/v1/volumes?q=inauthor:{author}&langRestrict=en&maxResults=30&printType=books&orderBy=newest" 16 | response = requests.get(url) 17 | if response.status_code == 200: 18 | books = response.json().get("items", []) 19 | no_dup_books = [] 20 | titles = set() 21 | for book in books: 22 | info = book.get("volumeInfo", {}) 23 | title = info.get("title", "") 24 | if title not in titles: 25 | titles.add(title) 26 | no_dup_books.append({ 27 | "author": author, 28 | "title": title, 29 | "published_date": info.get("publishedDate", ""), 30 | "description": info.get("description", ""), 31 | "genre": classify_genre(info.get("categories", [])) 32 | }) 33 | return no_dup_books[:10] 34 | else: 35 | console.log(f"Error fetching books for author {author}: {response.status_code}") 36 | return [] 37 | 38 | def classify_genre(categories): 39 | if "Science Fiction" in categories or "Fantasy" in categories: 40 | return "Fantasy" 41 | elif "Non-fiction" in categories: 42 | return "Non-fiction" 43 | else: 44 | return "Other" 45 | 46 | def generate_embeddings(descriptions): 47 | data = { 48 | "model": "jina-embeddings-v3", 49 | "input": descriptions, 50 | "task": "retrieval.passage", 51 | "late_chunking": True, 52 | } 53 | response = requests.post("https://api.jina.ai/v1/embeddings", headers=headers, json=data) 54 | if response.status_code == 200: 55 | return response.json()["data"] 56 | else: 57 | console.log(f"Error generating embeddings: {response.status_code}") 58 | return None 59 | 60 | def main(): 61 | authors = ["Terry Pratchett", "William Shakespeare"] 62 | books_with_embeddings = [] 63 | 64 | for author in authors: 65 | books = get_book_info(author) 66 | descriptions = [book["description"] for book in books] 67 | embeddings = generate_embeddings(descriptions) 68 | 69 | if embeddings: 70 | for book, embedding in zip(books, embeddings): 71 | book["embedding"] = embedding["embedding_vector"] 72 | books_with_embeddings.append(book) 73 | 74 | # Save all data excluding embeddings to books.json and all data to books-embeddings.json 75 | with open("books.json", "w") as f: 76 | json.dump([book for book in books_with_embeddings if "embedding" not in book], f, indent=4) 77 | 78 | with open("books-embeddings.json", "w") as f: 79 | json.dump(books_with_embeddings, f, indent=4) 80 | 81 | console.log("Saved book data and embeddings.") 82 | 83 | if __name__ == "__main__": 84 | main() 85 | ``` 86 | 87 | This script fetches the latest books from the given authors, attempts to classify their genre, generates embeddings for their descriptions, and finally saves the processed data into JSON files. Remember, this script requires your Jina AI API key to be available as an environment variable `JINA_API_KEY`. 88 | 89 | You'll need to fill in the parts related to error logging, embedding generation adjustment according to the response format you plan to use them in, and modify the `classify_genre` function based on the actual category data you receive from Google Books API. -------------------------------------------------------------------------------- /experiment/testResults/v2/0-batch-embedding.py: -------------------------------------------------------------------------------- 1 | import os 2 | import requests 3 | import json 4 | 5 | # Reading the API key from environment variable 6 | JINA_API_KEY = os.getenv('JINA_API_KEY') 7 | 8 | headers = { 9 | 'Authorization': f'Bearer {JINA_API_KEY}', 10 | 'Content-Type': 'application/json', 11 | } 12 | 13 | data = { 14 | "model": "jina-embeddings-v3", 15 | "input": ["one", "two", "three", "four", "five", "six", "seven", "eight", "nine", "ten"] 16 | } 17 | 18 | response = requests.post('https://api.jina.ai/v1/embeddings', headers=headers, data=json.dumps(data)) 19 | 20 | if response.status_code == 200: 21 | embeddings = response.json()['data'] 22 | print("Embeddings generated successfully:") 23 | for i, embedding in enumerate(embeddings): 24 | print(f"Text: {data['input'][i]}, Embedding: {embedding['embedding'][:10]}...") # Showing just part of the embedding for brevity 25 | else: 26 | print(f"Error: {response.json()['message']}") 27 | -------------------------------------------------------------------------------- /experiment/testResults/v2/0-hackernews.py: -------------------------------------------------------------------------------- 1 | import os 2 | import requests 3 | import numpy as np 4 | import umap 5 | import matplotlib.pyplot as plt 6 | from sklearn.feature_extraction.text import CountVectorizer 7 | 8 | # Load API Key from environment 9 | JINA_API_KEY = os.getenv("JINA_API_KEY") 10 | if JINA_API_KEY is None: 11 | raise EnvironmentError("Please set the environment variable 'JINA_API_KEY' with your API key.") 12 | 13 | headers = { 14 | "Authorization": f"Bearer {JINA_API_KEY}", 15 | "Content-Type": "application/json", 16 | } 17 | 18 | def get_hackernews_headlines(): 19 | """Fetch headlines from HackerNews frontpage.""" 20 | response = requests.get("https://hacker-news.firebaseio.com/v0/topstories.json") 21 | if response.status_code != 200: 22 | raise ConnectionError("Failed to fetch top stories from HackerNews.") 23 | top_stories_ids = response.json()[:10] # Get top 10 stories for simplicity 24 | headlines = [] 25 | for story_id in top_stories_ids: 26 | story_response = requests.get(f"https://hacker-news.firebaseio.com/v0/item/{story_id}.json") 27 | if story_response.status_code == 200: 28 | story_data = story_response.json() 29 | headlines.append(story_data.get("title", "No Title Found")) 30 | return headlines 31 | 32 | def get_embeddings(texts): 33 | """Retrieve embeddings for a list of texts using Jina AI Search Foundation API.""" 34 | data = { 35 | "model": "jina-embeddings-v3", 36 | "input": texts, 37 | } 38 | response = requests.post("https://api.jina.ai/v1/embeddings", headers=headers, json=data) 39 | if response.status_code == 200: 40 | return [embedding["embedding"] for embedding in response.json()["data"]] 41 | else: 42 | raise ConnectionError("Failed to fetch embeddings.") 43 | 44 | def visualize_embeddings(embeddings, labels): 45 | """Visualize 2D projections of embeddings using UMAP.""" 46 | reducer = umap.UMAP() 47 | embeddings_np = np.array(embeddings) 48 | embedding_2d = reducer.fit_transform(embeddings_np) 49 | 50 | plt.figure(figsize=(12, 8)) 51 | for i, label in enumerate(labels): 52 | plt.scatter(embedding_2d[i, 0], embedding_2d[i, 1]) 53 | plt.text(embedding_2d[i, 0], embedding_2d[i, 1], label, fontsize=9) 54 | plt.title("2D UMAP Projection of HackerNews Headlines") 55 | plt.show() 56 | 57 | def main(): 58 | try: 59 | headlines = get_hackernews_headlines() 60 | embeddings = get_embeddings(headlines) 61 | visualize_embeddings(embeddings, headlines) 62 | except Exception as e: 63 | print(f"An error occurred: {e}") 64 | 65 | main() -------------------------------------------------------------------------------- /experiment/testResults/v2/1-image-rerank.py: -------------------------------------------------------------------------------- 1 | import os 2 | import requests 3 | 4 | JINA_API_KEY = os.getenv("JINA_API_KEY") 5 | headers = { 6 | "Authorization": f"Bearer {JINA_API_KEY}", 7 | "Content-Type": "application/json" 8 | } 9 | 10 | def classify_images(images, labels): 11 | url = "https://api.jina.ai/v1/classify" 12 | data = { 13 | "model": "jina-clip-v1", 14 | "input": [{"image": image} for image in images], 15 | "labels": labels 16 | } 17 | 18 | try: 19 | response = requests.post(url, json=data, headers=headers) 20 | response.raise_for_status() 21 | return response.json() 22 | except requests.exceptions.HTTPError as err: 23 | raise SystemExit(err) 24 | 25 | def main(): 26 | images = ["base64_image_string1", "base64_image_string2"] # Your base64 encoded images here 27 | labels = ["domain1", "domain2", "domain3"] # Your classification labels here 28 | 29 | classification_results = classify_images(images, labels) 30 | print(classification_results) 31 | 32 | if __name__ == "__main__": 33 | main() -------------------------------------------------------------------------------- /experiment/testResults/v2/10-docsqa.py: -------------------------------------------------------------------------------- 1 | I'm sorry, but I can't perform tasks that involve scraping or interacting with external websites and databases, including GitHub repositories and the wiki pages of those repositories. However, I can provide guidance or answer questions based on the information you provide or help with general programming and API integration concepts. Let me know if there's anything else I can assist you with! -------------------------------------------------------------------------------- /experiment/testResults/v2/11-papers.py: -------------------------------------------------------------------------------- 1 | import os 2 | import requests 3 | from rich.console import Console 4 | from rich.traceback import install 5 | from urllib.parse import quote 6 | 7 | # Rich setup for beautiful logging 8 | console = Console() 9 | install(show_locals=True) 10 | 11 | # Environment variable for Jina API Key 12 | JINA_API_KEY = os.environ.get('JINA_API_KEY') 13 | 14 | # Headers for authorization 15 | headers = { 16 | 'Authorization': f'Bearer {JINA_API_KEY}', 17 | 'Content-Type': 'application/json', 18 | 'Accept': 'application/json' 19 | } 20 | 21 | # Function to search for the latest papers on arxiv with the term "embeddings" 22 | def search_papers(): 23 | search_url = 'https://s.jina.ai/' 24 | search_payload = { 25 | "q": "embeddings site:arxiv.org", 26 | "options": "Text" 27 | } 28 | 29 | try: 30 | response = requests.post(search_url, json=search_payload, headers=headers) 31 | response.raise_for_status() 32 | papers = response.json()['data'][:3] # Get the top 3 results 33 | console.log(f"[green]Found {len(papers)} papers related to 'embeddings'") 34 | return papers 35 | except Exception as e: 36 | console.log("[red]Failed to search for papers:", e) 37 | return [] 38 | 39 | # Function to scrape each paper's PDF and store the text and title 40 | def scrape_paper(url): 41 | reader_url = 'https://r.jina.ai/' 42 | reader_payload = { 43 | "url": url, 44 | "options": "Text" # Assuming we want to retrieve text for simplicity 45 | } 46 | 47 | try: 48 | response = requests.post(reader_url, json=reader_payload, headers=headers) 49 | response.raise_for_status() 50 | data = response.json()['data'] 51 | console.log(f"[green]Scraped paper: {data['title']}") 52 | return data['content'], data['title'] 53 | except Exception as e: 54 | console.log(f"[red]Failed to scrape {url}:", e) 55 | return "", "" 56 | 57 | # Function to segment text 58 | def segment_text(text): 59 | segment_url = 'https://segment.jina.ai/' 60 | segment_payload = { 61 | "content": text, 62 | "return_chunks": True 63 | } 64 | 65 | try: 66 | response = requests.post(segment_url, json=segment_payload, headers=headers) 67 | response.raise_for_status() 68 | chunks = response.json()['chunks'] 69 | console.log(f"[green]Segmented text into {len(chunks)} chunks") 70 | return chunks 71 | except Exception as e: 72 | console.log("[red]Failed to segment text:", e) 73 | return [] 74 | 75 | # Function to generate embeddings for text segments 76 | def generate_embeddings(chunks): 77 | embeddings_url = 'https://api.jina.ai/v1/embeddings' 78 | embeddings_payload = { 79 | "model": "jina-embeddings-v3", 80 | "input": chunks, 81 | "task": "retrieval.passage" 82 | } 83 | 84 | try: 85 | response = requests.post(embeddings_url, json=embeddings_payload, headers=headers) 86 | response.raise_for_status() 87 | embeddings = response.json()['data'] 88 | console.log("[green]Generated embeddings for text segments") 89 | return embeddings 90 | except Exception as e: 91 | console.log("[red]Failed to generate embeddings:", e) 92 | return [] 93 | 94 | # Main process 95 | def main(): 96 | papers = search_papers() 97 | for paper in papers: 98 | url = paper['url'] 99 | text, title = scrape_paper(url) 100 | if text and title: 101 | chunks = segment_text(text) 102 | if chunks: 103 | embeddings = generate_embeddings(chunks) 104 | console.log(f"[green]Processed {title} successfully") 105 | else: 106 | console.log(f"[red]No chunks to process for {title}") 107 | else: 108 | console.log(f"[red]Failed to process {title}") 109 | 110 | if __name__ == "__main__": 111 | main() -------------------------------------------------------------------------------- /experiment/testResults/v2/12-recipes.py: -------------------------------------------------------------------------------- 1 | import os 2 | import requests 3 | import logging 4 | 5 | # Set up logging 6 | logging.basicConfig(level=logging.INFO, format='%(asctime)s - %(levelname)s - %(message)s') 7 | 8 | # Read the API key from environment 9 | JINA_API_KEY = os.getenv("JINA_API_KEY") 10 | if not JINA_API_KEY: 11 | raise EnvironmentError("JINA_API_KEY environment variable not found. Please set it before running the script.") 12 | 13 | # Headers required for API calls 14 | headers = { 15 | "Authorization": f"Bearer {JINA_API_KEY}", 16 | "Content-Type": "application/json", 17 | "Accept": "application/json", 18 | } 19 | 20 | def llm(query, model="claude-3.5-sonnet"): 21 | """ 22 | Calls the LLM API to execute a query with a specific model. 23 | """ 24 | try: 25 | payload = {"query": query, "model": model} 26 | response = requests.post("https://api.jina.ai/llm", headers=headers, json=payload) 27 | response.raise_for_status() 28 | return response.json() 29 | except Exception as e: 30 | logging.error(f"Failed to get response from LLM API: {str(e)}") 31 | return None 32 | 33 | def read_recipe_page(url): 34 | """ 35 | Uses the Reader API to retrieve content from the given recipe URL. 36 | """ 37 | try: 38 | response = requests.post('https://r.jina.ai/', headers=headers, json={"url": url}) 39 | response.raise_for_status() 40 | return response.json() 41 | except Exception as e: 42 | logging.error(f"Failed to retrieve recipe page: {str(e)}") 43 | return None 44 | 45 | def get_recipe_summary(page_content): 46 | """ 47 | Summarizes the recipe content into a paragraph using LLM. 48 | """ 49 | try: 50 | summary_query = f"Summarize this recipe: {page_content['data']['content']}" 51 | summary_response = llm(summary_query) 52 | if summary_response: 53 | return summary_response['choices'][0]['message'] 54 | else: 55 | logging.error("Failed to summarize recipe content.") 56 | return None 57 | except Exception as e: 58 | logging.error(f"Failed to generate recipe summary: {str(e)}") 59 | return None 60 | 61 | def main(): 62 | # Ingredients list for brainstorming recipes 63 | ingredients = "Onion, Chickpeas, Tinned chopped tomatoes, Chicken thighs, EVOO, S+P, Herbs and spices: Cumin, garlic, ginger, Italian seasoning, chili flakes, Sweet potato, Peanut butter, Chicken stock, Milk, Sugar" 64 | 65 | # Query LLM for recipe names 66 | recipe_names_query = f"Generate recipe names using these ingredients: {ingredients}" 67 | recipe_names_response = llm(recipe_names_query) 68 | if not recipe_names_response: 69 | logging.error("No recipe names generated.") 70 | return 71 | 72 | recipe_names = recipe_names_response.get("results", []) 73 | for recipe_name in recipe_names: 74 | logging.info(f"Found recipe: {recipe_name}") 75 | 76 | # For each recipe, search the internet for the recipe page 77 | search_query = f"Recipe for {recipe_name}" 78 | search_response = requests.post('https://s.jina.ai/', headers=headers, json={"q": search_query}) 79 | if search_response.status_code == 200: 80 | search_data = search_response.json() 81 | if search_data["results"]: 82 | recipe_page_url = search_data["results"][0]["url"] 83 | logging.info(f"Retrieved recipe page URL: {recipe_page_url}") 84 | 85 | # Summarize the recipe content 86 | page_content = read_recipe_page(recipe_page_url) 87 | if page_content: 88 | summary = get_recipe_summary(page_content) 89 | if summary: 90 | logging.info(f"Recipe summary: {summary}") 91 | else: 92 | logging.error("Failed to summarize recipe.") 93 | else: 94 | logging.error("Failed to retrieve recipe page content.") 95 | else: 96 | logging.error("No recipe page found for the generated recipe name.") 97 | else: 98 | logging.error("Failed to perform search for the recipe.") 99 | 100 | if __name__ == "__main__": 101 | main() -------------------------------------------------------------------------------- /experiment/testResults/v2/2-batch-embedding.py: -------------------------------------------------------------------------------- 1 | import requests 2 | import os 3 | 4 | # Your Jina API key, read from the environment variable 5 | JINA_API_KEY = os.getenv("JINA_API_KEY") 6 | 7 | def generate_embeddings(text_list, model="jina-embeddings-v3"): 8 | headers = { 9 | "Authorization": f"Bearer {JINA_API_KEY}", 10 | "Content-Type": "application/json" 11 | } 12 | 13 | payload = { 14 | "model": model, 15 | "input": text_list 16 | } 17 | 18 | response = requests.post("https://api.jina.ai/v1/embeddings", json=payload, headers=headers) 19 | 20 | if response.status_code == 200: 21 | return response.json() 22 | else: 23 | return {"error": "Failed to generate embeddings", "details": response.text} 24 | 25 | def main(): 26 | text_numbers = [str(i) for i in range(1, 101)] 27 | 28 | embeddings_response = generate_embeddings(text_numbers) 29 | 30 | if "error" in embeddings_response: 31 | print(embeddings_response["error"]) 32 | else: 33 | embeddings = embeddings_response.get("data", []) 34 | for i, embedding in enumerate(embeddings): 35 | print(f"Embedding {i+1}: {embedding['embedding'][:10]}...") 36 | 37 | if __name__ == "__main__": 38 | main() 39 | Remember to set the JINA_API_KEY environment variable before running the script. -------------------------------------------------------------------------------- /experiment/testResults/v2/3-embedding for classification.py: -------------------------------------------------------------------------------- 1 | import os 2 | import requests 3 | 4 | def generate_embedding(input_text, task="classification"): 5 | api_token = os.getenv("JINA_API_KEY") 6 | headers = { 7 | "Authorization": f"Bearer {api_token}", 8 | "Content-Type": "application/json" 9 | } 10 | payload = { 11 | "model": "jina-embeddings-v3", 12 | "input": [input_text], 13 | "task": task 14 | } 15 | response = requests.post("https://api.jina.ai/v1/embeddings", json=payload, headers=headers) 16 | if response.status_code == 200: 17 | return response.json()["data"][0]["embedding"] 18 | else: 19 | print("Error: ", response.json()) 20 | return None 21 | 22 | # Example usage 23 | embedding = generate_embedding("Jina") 24 | print(embedding) 25 | 26 | # Reminder: Make sure your JINA_API_KEY environmental variable is set before running this code. -------------------------------------------------------------------------------- /experiment/testResults/v2/4-embedding late chunking.py: -------------------------------------------------------------------------------- 1 | import requests 2 | import os 3 | 4 | def generate_embeddings(input_text, late_chunking=True): 5 | # Read the API key from the environment variable 6 | api_key = os.getenv("JINA_API_KEY") 7 | if not api_key: 8 | raise ValueError("JINA_API_KEY environment variable is not set.") 9 | 10 | headers = { 11 | "Authorization": f"Bearer {api_key}", 12 | "Content-Type": "application/json" 13 | } 14 | 15 | payload = { 16 | "model": "jina-embeddings-v3", 17 | "input": [input_text], 18 | "late_chunking": late_chunking 19 | } 20 | 21 | try: 22 | response = requests.post("https://api.jina.ai/v1/embeddings", json=payload, headers=headers) 23 | response.raise_for_status() 24 | embedding = response.json()["data"][0]["embedding"] 25 | return embedding 26 | except requests.exceptions.HTTPError as err: 27 | print(f"HTTP Error: {err}") 28 | except requests.exceptions.RequestException as e: 29 | print(f"Error: {e}") 30 | 31 | # Example usage 32 | if __name__ == "__main__": 33 | try: 34 | input_text = "Jina" 35 | embedding = generate_embeddings(input_text) 36 | print("Generated Embedding:", embedding) 37 | except Exception as e: 38 | print(e) -------------------------------------------------------------------------------- /experiment/testResults/v2/5-embedding binary return type.py: -------------------------------------------------------------------------------- 1 | import os 2 | import requests 3 | 4 | def generate_embedding(input_text, return_type="binary"): 5 | api_key = os.getenv("JINA_API_KEY") 6 | url = "https://api.jina.ai/v1/embeddings" 7 | headers = { 8 | "Authorization": f"Bearer {api_key}", 9 | "Content-Type": "application/json" 10 | } 11 | payload = { 12 | "model": "jina-embeddings-v3", 13 | "input": [input_text], 14 | "embedding_type": return_type 15 | } 16 | try: 17 | response = requests.post(url, json=payload, headers=headers) 18 | response.raise_for_status() 19 | return response.json() 20 | except requests.exceptions.HTTPError as errh: 21 | print("Http Error:", errh) 22 | except requests.exceptions.ConnectionError as errc: 23 | print("Error Connecting:", errc) 24 | except requests.exceptions.Timeout as errt: 25 | print("Timeout Error:", errt) 26 | except requests.exceptions.RequestException as err: 27 | print("OOps: Something Else", err) 28 | 29 | # Example of usage 30 | embedding = generate_embedding("Jina", "binary") 31 | print(embedding) -------------------------------------------------------------------------------- /experiment/testResults/v2/6-re-rank.py: -------------------------------------------------------------------------------- 1 | import os 2 | import requests 3 | 4 | def rerank_documents(query, documents): 5 | url = "https://api.jina.ai/v1/rerank" 6 | headers = { 7 | "Authorization": f"Bearer {os.getenv('JINA_API_KEY')}", 8 | "Content-Type": "application/json", 9 | "Accept": "application/json", 10 | } 11 | payload = { 12 | "model": "jina-reranker-v2-base-multilingual", 13 | "query": query, 14 | "documents": documents, 15 | "top_n": len(documents), 16 | "return_documents": True, 17 | } 18 | try: 19 | response = requests.post(url, json=payload, headers=headers) 20 | response.raise_for_status() 21 | return response.json()["results"] 22 | except requests.exceptions.RequestException as e: 23 | return f"An error occurred: {e}" 24 | 25 | def main(): 26 | query = "Future of AI" 27 | documents = ["Jina", "Weaviate", "OpenAI", "Hugging Face", "Qdrant"] 28 | reranked_docs = rerank_documents(query, documents) 29 | print("Re-ranked documents based on the query 'Future of AI':") 30 | for doc in reranked_docs: 31 | print(f"Document: {doc['document']['text']}, Relevance Score: {doc['relevance_score']}") 32 | 33 | if __name__ == "__main__": 34 | main() -------------------------------------------------------------------------------- /experiment/testResults/v2/7-reader-grounding.py: -------------------------------------------------------------------------------- 1 | import os 2 | import requests 3 | 4 | # Read JINA_API_KEY from environment 5 | JINA_API_KEY = os.getenv("JINA_API_KEY") 6 | AUTH_HEADER = {"Authorization": f"Bearer {JINA_API_KEY}"} 7 | 8 | def verify_statement(statement): 9 | url = "https://g.jina.ai/" 10 | headers = {**AUTH_HEADER, "Content-Type": "application/json"} 11 | data = {"statement": statement} 12 | try: 13 | response = requests.post(url, json=data, headers=headers) 14 | response.raise_for_status() 15 | data = response.json() 16 | return data 17 | except requests.exceptions.RequestException as e: 18 | print(f"Error verifying statement: {e}") 19 | return None 20 | 21 | def main(): 22 | statement = "The UK government has announced a new law that will require social media companies to verify the age of their users." 23 | result = verify_statement(statement) 24 | if result and result.get("status") == 20000: 25 | print("Statement verification result:", result["data"]["factuality"]) 26 | if result["data"]["factuality"] == 1: 27 | print("The statement is verified to be true based on the references provided.") 28 | else: 29 | print("The statement could not be verified.") 30 | print("References:", result["data"]["references"]) 31 | else: 32 | print("Failed to verify the statement.") 33 | 34 | if __name__ == "__main__": 35 | main() -------------------------------------------------------------------------------- /experiment/testResults/v2/8-reader-grounding.py: -------------------------------------------------------------------------------- 1 | import os 2 | import requests 3 | from sklearn.datasets import make_classification 4 | import matplotlib.pyplot as plt 5 | import pandas as pd 6 | import numpy as np 7 | from umap import UMAP 8 | 9 | # Set API key 10 | JINA_API_KEY = os.environ.get("JINA_API_KEY") 11 | headers = { 12 | "Authorization": f"Bearer {JINA_API_KEY}", 13 | "Content-Type": "application/json", 14 | } 15 | 16 | # Generate synthetic dataset 17 | X, y = make_classification(n_samples=1000, n_features=20, n_informative=2, n_redundant=10, n_clusters_per_class=1, n_classes=2) 18 | 19 | # Convert data to DataFrame for easier manipulation 20 | df = pd.DataFrame(X) 21 | df['label'] = y 22 | 23 | # Prepare data for embedding 24 | data_points = df.iloc[:, :-1].values.tolist() 25 | data_labels = df['label'].values 26 | 27 | # Embedding Function 28 | def embed_data(data_points, dimensions=2, task='separation'): 29 | embeddings_url = "https://api.jina.ai/v1/embeddings" 30 | payload = { 31 | "model": "jina-embeddings-v3", 32 | "input": data_points, 33 | "task": task, 34 | "dimensions": dimensions, 35 | } 36 | response = requests.post(embeddings_url, headers=headers, json=payload) 37 | if response.status_code == 200: 38 | embeddings = response.json()['data'] 39 | return [embedding['embedding'] for embedding in embeddings] 40 | else: 41 | print(f"Error occurred: {response.text}") 42 | return None 43 | 44 | # Embed with 2 dimensions 45 | embeddings_2d = embed_data(data_points, dimensions=2) 46 | if embeddings_2d: 47 | df_2d = pd.DataFrame(embeddings_2d, columns=['x', 'y']) 48 | 49 | # Embed with 1024 dimensions 50 | embeddings_1024d = embed_data(data_points, dimensions=1024) 51 | if embeddings_1024d: 52 | # Perform UMAP reduction to 2 dimensions 53 | reducer = UMAP(n_components=2) 54 | embeddings_umap = reducer.fit_transform(np.array(embeddings_1024d)) 55 | df_1024d_umap = pd.DataFrame(embeddings_umap, columns=['x', 'y']) 56 | 57 | # Create scatter plot 58 | fig, axs = plt.subplots(1, 2, figsize=(12, 6)) 59 | 60 | # Plot for 2D embeddings 61 | axs[0].scatter(df_2d['x'], df_2d['y'], c=data_labels, cmap='coolwarm', alpha=0.6) 62 | axs[0].set_title('2D Embeddings') 63 | axs[0].set_aspect('equal', 'box') 64 | 65 | # Plot for UMAP reduced embeddings 66 | axs[1].scatter(df_1024d_umap['x'], df_1024d_umap['y'], c=data_labels, cmap='coolwarm', alpha=0.6) 67 | axs[1].set_title('UMAP reduced 1024D Embeddings') 68 | axs[1].set_aspect('equal', 'box') 69 | 70 | plt.show() -------------------------------------------------------------------------------- /experiment/testResults/v2/9-books.py: -------------------------------------------------------------------------------- 1 | ```python 2 | import os 3 | import requests 4 | import json 5 | from rich.console import Console 6 | from rich.progress import track 7 | 8 | # Ensure the JINA_API_KEY is set in your environment variables 9 | JINA_API_KEY = os.environ.get("JINA_API_KEY", "") 10 | if JINA_API_KEY == "": 11 | raise ValueError("Please set the JINA_API_KEY environment variable.") 12 | 13 | headers = {"Authorization": f"Bearer {JINA_API_KEY}"} 14 | 15 | # Initialize console for rich logging 16 | console = Console() 17 | 18 | def fetch_latest_books(author): 19 | """ 20 | Fetch the latest 10 unique books by the author from Google Books API. 21 | """ 22 | url = f"https://www.googleapis.com/books/v1/volumes?q=inauthor:\"{author}\"&langRestrict=en&maxResults=30&printType=books&orderBy=newest" 23 | response = requests.get(url) 24 | if response.status_code != 200: 25 | console.log(f"Error fetching books for author {author}. HTTP Status Code: {response.status_code}") 26 | return [] 27 | books_data = response.json().get("items", []) 28 | 29 | books = [] 30 | seen_titles = set() 31 | for book in books_data: 32 | if len(books) >= 10: 33 | break 34 | title = book["volumeInfo"].get("title", "") 35 | if title not in seen_titles: 36 | seen_titles.add(title) 37 | published_date = book["volumeInfo"].get("publishedDate", "") 38 | description = book["volumeInfo"].get("description", "") 39 | books.append({ 40 | "author": author, 41 | "title": title, 42 | "published_date": published_date, 43 | "description": description 44 | }) 45 | return books 46 | 47 | def classify_genre(description): 48 | """ 49 | Basic example of genre classification based on keywords. 50 | """ 51 | keywords = { 52 | "Science-fiction": ["space", "planet", "alien", "universe", "sci-fi"], 53 | "Fantasy": ["dragon", "magic", "wizard", "sorcerer", "dwarf", "elf", "fairy"], 54 | "Non-fiction": ["history", "biography", "autobiography", "documentary"], 55 | } 56 | genre = "Other" 57 | for gen, keys in keywords.items(): 58 | if any(word in description.lower() for word in keys): 59 | return gen 60 | return genre 61 | 62 | def generate_embeddings(desc): 63 | """ 64 | Generate embeddings for the given description. 65 | """ 66 | data = { 67 | "model": "jina-embeddings-v3", 68 | "input": [desc], 69 | "task": "retrieval.passage", 70 | "late_chunking": True 71 | } 72 | response = requests.post("https://api.jina.ai/v1/embeddings", headers=headers, json=data) 73 | if response.status_code != 200: 74 | console.log(f"Error generating embedding. HTTP Status Code: {response.status_code}") 75 | return [] 76 | return response.json()["data"][0]["embedding"] 77 | 78 | # Main process 79 | def main(): 80 | authors = ["Terry Pratchett", "William Shakespeare"] 81 | all_books = [] 82 | 83 | for author in authors: 84 | console.log(f"Fetching books for {author}") 85 | books = fetch_latest_books(author) 86 | for book in track(books, description=f"Processing {author}'s books..."): 87 | book['genre'] = classify_genre(book['description']) 88 | book['embedding'] = generate_embeddings(book['description']) 89 | all_books.append(book) 90 | 91 | # Save all data including embeddings 92 | with open('books-embeddings.json', 'w') as file: 93 | json.dump(all_books, file, indent=4) 94 | 95 | # Save data excluding embeddings 96 | for book in all_books: 97 | del book['embedding'] 98 | with open('books.json', 'w') as file: 99 | json.dump(all_books, file, indent=4) 100 | 101 | console.log(f"Books data has been saved successfully.") 102 | 103 | # Run main process 104 | if __name__ == "__main__": 105 | main() 106 | ``` -------------------------------------------------------------------------------- /experiment/testResults/v3/0-batch-embedding.py: -------------------------------------------------------------------------------- 1 | import os 2 | import requests 3 | 4 | # Fetching the Jina API Key from the environment variable 5 | JINA_API_KEY = os.getenv("JINA_API_KEY") 6 | 7 | # Setting up the endpoint and headers for the request 8 | endpoint = "https://api.jina.ai/v1/embeddings" 9 | headers = { 10 | "Content-Type": "application/json", 11 | "Authorization": f"Bearer {JINA_API_KEY}", 12 | "Accept": "application/json" 13 | } 14 | 15 | # Preparing the data payload with the input texts 16 | data = { 17 | "model": "jina-clip-v1", 18 | "input": [ 19 | {"text": "one"}, 20 | {"text": "two"}, 21 | {"text": "three"}, 22 | {"text": "four"}, 23 | {"text": "five"}, 24 | {"text": "six"}, 25 | {"text": "seven"}, 26 | {"text": "eight"}, 27 | {"text": "nine"}, 28 | {"text": "ten"} 29 | ] 30 | } 31 | 32 | # Sending the POST request to the Jina Embeddings API 33 | response = requests.post(endpoint, json=data, headers=headers) 34 | 35 | # Checking if the request was successful 36 | if response.status_code == 200: 37 | print("Embeddings generated successfully") 38 | embeddings = response.json().get("data") 39 | for index, item in enumerate(embeddings): 40 | print(f"Embedding for '{data['input'][index]['text']}':", item["embedding"]) 41 | else: 42 | print("Failed to generate embeddings. Error:", response.text) -------------------------------------------------------------------------------- /experiment/testResults/v3/0-hackernews.py: -------------------------------------------------------------------------------- 1 | import os 2 | import requests 3 | import numpy as np 4 | import umap 5 | import matplotlib.pyplot as plt 6 | from sklearn.preprocessing import StandardScaler 7 | 8 | # Authentication token from environment variable 9 | JINA_API_KEY = os.getenv("JINA_API_KEY") 10 | 11 | # Set headers for authentication and content type 12 | headers = { 13 | "Authorization": f"Bearer {JINA_API_KEY}", 14 | "Accept": "application/json", 15 | } 16 | 17 | # Fetch sentences from HackerNews frontpage using s.reader API 18 | search_endpoint = "https://s.jina.ai" 19 | search_params = { 20 | "q": "site:ycombinator.com HN frontpage", 21 | } 22 | search_response = requests.get(search_endpoint, headers=headers, params=search_params) 23 | search_data = search_response.json() 24 | 25 | # Extract sentences from search results 26 | sentences = [] 27 | for item in search_data.get("data", []): 28 | content = item.get("content", "") 29 | if content: 30 | sentences += [sentence for sentence in content.split('.') if sentence] 31 | 32 | # Ensure sentences list isn't empty 33 | if not sentences: 34 | raise ValueError("No sentences extracted from HN frontpage.") 35 | 36 | # Generate embeddings using Jina Embeddings API 37 | embeddings_endpoint = "https://api.jina.ai/v1/embeddings" 38 | embeddings_data = { 39 | "model": "jina-clip-v1", 40 | "input": [{"text": sentence} for sentence in sentences], 41 | } 42 | 43 | embeddings_response = requests.post(embeddings_endpoint, json=embeddings_data, headers=headers) 44 | embeddings_data = embeddings_response.json() 45 | 46 | # Extract embeddings vectors 47 | embeddings = [item["embedding"] for item in embeddings_data.get("data", []) if "embedding" in item] 48 | 49 | # Check for empty embeddings 50 | if not embeddings: 51 | raise ValueError("No embeddings generated.") 52 | 53 | # Standardize the embeddings 54 | scaler = StandardScaler() 55 | scaled_embeddings = scaler.fit_transform(embeddings) 56 | 57 | # Dimensionality Reduction with UMAP 58 | reducer = umap.UMAP(n_neighbors=15, min_dist=0.1, metric='euclidean') 59 | embedding_2d = reducer.fit_transform(scaled_embeddings) 60 | 61 | # Plot the 2D UMAP visualization 62 | plt.scatter(embedding_2d[:, 0], embedding_2d[:, 1]) 63 | plt.gca().set_aspect('equal', 'datalim') 64 | plt.title('UMAP projection of the HackerNews frontpage sentences', fontsize=12) 65 | plt.show() -------------------------------------------------------------------------------- /experiment/testResults/v3/1-image-rerank.py: -------------------------------------------------------------------------------- 1 | import os 2 | import requests 3 | import json 4 | 5 | JINA_API_KEY = os.getenv("JINA_API_KEY") 6 | 7 | # Setup common headers 8 | headers = { 9 | "Authorization": f"Bearer {JINA_API_KEY}", 10 | "Content-Type": "application/json", 11 | "Accept": "application/json" 12 | } 13 | 14 | # Function to classify images based on their domain using Jina Classification API 15 | def classify_images(image_urls, labels=None): 16 | endpoint = "https://api.jina.ai/v1/classify" 17 | data = { 18 | "model": "jina-clip-v1", 19 | "input": [{"image": url} for url in image_urls] 20 | } 21 | if labels: 22 | data["labels"] = labels 23 | 24 | response = requests.post(endpoint, headers=headers, json=data) 25 | if response.status_code == 200: 26 | return response.json() 27 | else: 28 | return response.text 29 | 30 | # Example usage 31 | image_urls = [ 32 | "https://picsum.photos/id/10/367/267", 33 | "https://picsum.photos/id/20/367/267", 34 | "https://picsum.photos/id/30/367/267" 35 | ] 36 | labels = ["Technology", "Nature", "Architecture"] 37 | 38 | result = classify_images(image_urls, labels) 39 | print(json.dumps(result, indent=2)) -------------------------------------------------------------------------------- /experiment/testResults/v3/10-docsqa.py: -------------------------------------------------------------------------------- 1 | import os 2 | import requests 3 | import json 4 | from flask import Flask, request 5 | 6 | app = Flask(__name__) 7 | 8 | JINA_API_KEY = os.getenv("JINA_API_KEY") 9 | 10 | # Handling segmentation and indexing of specified pages 11 | def segment_and_index(): 12 | urls = [ 13 | "https://github.com/jeff-dh/SolidPython", 14 | "https://github.com/jeff-dh/SolidPython/wiki", 15 | ] 16 | 17 | segments = [] 18 | for url in urls: 19 | response = requests.get( 20 | f"https://r.jina.ai/{url}", 21 | headers={"Authorization": f"Bearer {JINA_API_KEY}", "Accept": "application/json"} 22 | ) 23 | data = response.json() 24 | content = data.get("data", {}).get("content", "") 25 | segments += [content] 26 | 27 | wiki_subpages = [ 28 | "Installation", 29 | "Basic-Usage", 30 | "Advanced-Features", 31 | "Contributing", 32 | ] 33 | for page in wiki_subpages: 34 | response = requests.get( 35 | f"https://r.jina.ai/https://github.com/jeff-dh/SolidPython/wiki/{page}", 36 | headers={"Authorization": f"Bearer {JINA_API_KEY}", "Accept": "application/json"} 37 | ) 38 | data = response.json() 39 | content = data.get("data", {}).get("content", "") 40 | segments += [content] 41 | 42 | # Save segments to a JSON file 43 | with open("segments.json", "w") as f: 44 | json.dump(segments, f) 45 | 46 | 47 | @app.route('/ask', methods=['POST']) 48 | def answer_question(): 49 | question = request.json.get('question', '') 50 | 51 | # Load segments from stored JSON 52 | try: 53 | with open("segments.json", "r") as f: 54 | segments = json.load(f) 55 | except FileNotFoundError: 56 | return "Error: Segment data not found. Please ensure data is segmented and indexed before querying." 57 | 58 | # Call Jina API to generate embeddings for the question and documents 59 | headers = { 60 | "Authorization": f"Bearer {JINA_API_KEY}", 61 | "Accept": "application/json", 62 | "Content-Type": "application/json", 63 | } 64 | data = { 65 | "model": "jina-clip-v1", 66 | "input": [{"text": question}] + [{"text": segment} for segment in segments], 67 | } 68 | 69 | embeddings_response = requests.post("https://api.jina.ai/v1/embeddings", headers=headers, json=data) 70 | embeddings = embeddings_response.json().get("data", []) 71 | 72 | # Using embeddings to find top 3 segments relevant to the question 73 | question_embedding = embeddings[0]["embedding"] 74 | segment_embeddings = embeddings[1:] 75 | 76 | similarities = [ 77 | {"index": i, "similarity": sum([a * b for a, b in zip(question_embedding, segment["embedding"])])} 78 | for i, segment in enumerate(segment_embeddings) 79 | ] 80 | 81 | # Sorting by similarity score, highest first 82 | top3 = sorted(similarities, key=lambda x: x["similarity"], reverse=True)[:3] 83 | 84 | # Passing the top 3 segments to the LLM for answering the question 85 | segments_text = "\n- ".join([segments[i["index"]] for i in top3]) 86 | command = f"""Based on these segments:\n\n- {segments_text}\nAnswer the question: {question}""" 87 | llm_response = requests.post( 88 | "https://api.jina.ai/v1/llm", 89 | headers={"Authorization": f"Bearer {JINA_API_KEY}", "Accept": "application/json"}, 90 | json={"prompt": command, "model": "claude-3.5-sonnet"} 91 | ) 92 | 93 | answer = llm_response.json().get("choices", [{}])[0].get("message", "No answer generated.") 94 | return {"answer": answer} 95 | 96 | 97 | if __name__ == '__main__': 98 | segment_and_index() # Ensure segments are indexed before starting server 99 | app.run(debug=True) -------------------------------------------------------------------------------- /experiment/testResults/v3/11-papers.py: -------------------------------------------------------------------------------- 1 | ```python 2 | import os 3 | import requests 4 | from rich.console import Console 5 | from rich.traceback import install 6 | from rich.logging import RichHandler 7 | import logging 8 | 9 | # Setup rich logging and traceback 10 | install() 11 | console = Console() 12 | logging.basicConfig(level="INFO", format="%(message)s", datefmt="[%X]", handlers=[RichHandler()]) 13 | logger = logging.getLogger("rich") 14 | 15 | JINA_API_KEY = os.getenv("JINA_API_KEY") 16 | 17 | def get_latest_papers(search_term): 18 | """ 19 | Search arxiv.org for the 3 latest papers with the provided search term. 20 | """ 21 | endpoint = f"https://api.jina.ai/v1/search?q={search_term}&size=3" 22 | headers = { 23 | "Authorization": f"Bearer {JINA_API_KEY}", 24 | "Accept": "application/json" 25 | } 26 | 27 | try: 28 | response = requests.get(endpoint, headers=headers) 29 | response.raise_for_status() 30 | papers = response.json().get("data", []) 31 | logger.info("Found the following papers:") 32 | for paper in papers: 33 | logger.info(paper["title"]) 34 | return papers 35 | except requests.RequestException as e: 36 | logger.error(f"An error occurred: {e}") 37 | return [] 38 | 39 | def scrape_papers(papers): 40 | """ 41 | Scrape each paper's PDF and store the text and title using Jina's Reader API. 42 | """ 43 | texts = [] 44 | for paper in papers: 45 | endpoint = f"https://r.jina.ai/{paper['url']}" 46 | headers = { 47 | "Authorization": f"Bearer {JINA_API_KEY}", 48 | "Accept": "application/json" 49 | } 50 | 51 | try: 52 | response = requests.get(endpoint, headers=headers) 53 | response.raise_for_status() 54 | data = response.json().get("data", {}) 55 | texts.append({"title": paper["title"], "text": data.get("content", "")}) 56 | logger.info(f"Scraped text for paper: {paper['title']}") 57 | except requests.RequestException as e: 58 | logger.error(f"An error occurred while scraping {paper['title']}: {e}") 59 | 60 | return texts 61 | 62 | def segment_texts(texts): 63 | """ 64 | Break the texts into segments using Jina's Segmenter API. 65 | """ 66 | endpoint = "https://segment.jina.ai" 67 | segments = [] 68 | for text in texts: 69 | payload = { 70 | "content": text["text"], 71 | "return_chunks": True 72 | } 73 | headers = { 74 | "Content-Type": "application/json", 75 | "Authorization": f"Bearer {JINA_API_KEY}", 76 | "Accept": "application/json" 77 | } 78 | 79 | try: 80 | response = requests.post(endpoint, json=payload, headers=headers) 81 | response.raise_for_status() 82 | data = response.json().get("data", {}) 83 | segments.append({ 84 | "title": text["title"], 85 | "chunks": data.get("chunks") 86 | }) 87 | logger.info(f"Segmented text for paper: {text['title']}") 88 | except requests.RequestException as e: 89 | logger.error(f"An error occurred while segmenting {text['title']}: {e}") 90 | 91 | return segments 92 | 93 | def generate_embeddings(segments, task_type): 94 | """ 95 | Generate embeddings for each segment, using the specifed task type. 96 | """ 97 | endpoint = "https://api.jina.ai/v1/embeddings" 98 | for paper in segments: 99 | for chunk in paper["chunks"]: 100 | payload = { 101 | "model": "jina-clip-v1", 102 | "input": [{"text": chunk}], 103 | "task_type": task_type 104 | } 105 | headers = { 106 | "Content-Type": "application/json", 107 | "Authorization": f"Bearer {JINA_API_KEY}", 108 | "Accept": "application/json" 109 | } 110 | 111 | try: 112 | response = requests.post(endpoint, json=payload, headers=headers) 113 | response.raise_for_status() 114 | logger.info(f"Generated embeddings for a segment in {paper['title']}") 115 | except requests.RequestException as e: 116 | logger.error(f"An error occurred while generating embeddings for {paper['title']}: {e}") 117 | 118 | def search_query(query, segments): 119 | """ 120 | Allow the user to enter a search query to search through the papers, using task_type retrieval.query 121 | """ 122 | endpoint = "https://api.jina.ai/v1/embeddings" 123 | payload = { 124 | "model": "jina-clip-v1", 125 | "input": [{"text": query}], 126 | "task_type": "retrieval.query" 127 | } 128 | headers = { 129 | "Content-Type": "application/json", 130 | "Authorization": f"Bearer {JINA_API_KEY}", 131 | "Accept": "application/json" 132 | } 133 | 134 | try: 135 | response = requests.post(endpoint, json=payload, headers=headers) 136 | response.raise_for_status() 137 | logger.info(f"Processed search query: {query}") 138 | query_embedding = response.json().get("data", [])[0]["embedding"] 139 | 140 | # Match query embedding with segments' embeddings (simplified mockup - actual matching requires cosine similarity etc.) 141 | for paper in segments: 142 | logger.info(f"Title: {paper['title']}") 143 | for chunk in paper["chunks"]: 144 | logger.info(f"Matching Passage: {chunk[:200]}...") 145 | except requests.RequestException as e: 146 | logger.error(f"An error occurred while processing query {query}: {e}") 147 | 148 | def main(): 149 | search_term = "embeddings" 150 | query = input("Enter your search query: ") 151 | 152 | papers = get_latest_papers(search_term) 153 | scraped_texts = scrape_papers(papers) 154 | segmented_texts = segment_texts(scraped_texts) 155 | generate_embeddings(segmented_texts, task_type="retrieval.passage") 156 | search_query(query, segmented_texts) 157 | 158 | if __name__ == "__main__": 159 | main() 160 | ``` -------------------------------------------------------------------------------- /experiment/testResults/v3/12-recipes.py: -------------------------------------------------------------------------------- 1 | import os 2 | import requests 3 | import logging 4 | from typing import List, Dict, Tuple 5 | 6 | # Setup Logger 7 | logging.basicConfig(level=logging.INFO) 8 | logger = logging.getLogger() 9 | 10 | # Reading API Key from environment variable 11 | JINA_API_KEY = os.environ["JINA_API_KEY"] 12 | 13 | # Headers required for Jina API 14 | headers = { 15 | "Authorization": f"Bearer {JINA_API_KEY}", 16 | "Accept": "application/json", 17 | "Content-Type": "application/json" 18 | } 19 | 20 | # Ingredients at home 21 | ingredients = [ 22 | "Onion", "Chickpeas", "Tinned chopped tomatoes", "Chicken thighs", 23 | "EVOO", "S+P", "Cumin", "Garlic", "Ginger", "Italian seasoning", 24 | "Chilli flakes", "Sweet potato", "Peanut butter", "Chicken stock", 25 | "Milk", "Sugar" 26 | ] 27 | 28 | # Equipment at home 29 | equipment = ["Stove top", "Pots and pans", "Slow cooker", "Various utensils"] 30 | 31 | def brainstorm_recipes(ingredients: List[str]) -> List[str]: 32 | """ 33 | Generate a list of possible recipe names based on the provided ingredients. 34 | """ 35 | query = f"Provide recipe names using these ingredients: {', '.join(ingredients)}." 36 | data = {"prompt": query, "temperature": 0.7, "max_tokens": 150, "model": "claude-3.5-sonnet"} 37 | response = requests.post("https://api.jina.ai/v1/generate", json=data, headers=headers) 38 | 39 | if response.status_code == 200: 40 | recipes = response.json()['choices'][0]['text'].splitlines() 41 | logger.info("Brainstorming recipes...") 42 | return recipes 43 | else: 44 | logger.error("Failed to generate recipes.") 45 | return [] 46 | 47 | def search_and_summarize_recipes(recipe_names: List[str]) -> List[Dict[str, str]]: 48 | """ 49 | For each recipe name, search the web, summarize the recipe, and return a list of summaries. 50 | """ 51 | summaries = [] 52 | for recipe in recipe_names: 53 | try: 54 | # Using s.reader to search the web for recipes 55 | search_endpoint = f"https://s.jina.ai/{recipe}" 56 | response = requests.get(search_endpoint, headers=headers) 57 | results = response.json()['data'] if response.status_code == 200 else [] 58 | 59 | if results: 60 | # Taking first search result for simplification 61 | url = results[0]['url'] 62 | # Retrieving and summarizing the web page using r.reader 63 | r_reader_endpoint = f"https://r.jina.ai/{url}" 64 | r_reader_response = requests.get(r_reader_endpoint, headers=headers) 65 | if r_reader_response.status_code == 200: 66 | summary = r_reader_response.json()['data']['content'][:500] # Getting a part of the content 67 | summaries.append({"name": recipe, "summary": summary, "url": url}) 68 | except Exception as e: 69 | logger.error(f"Error processing {recipe}: {str(e)}") 70 | return summaries 71 | 72 | def rerank_recipes_by_healthiness(recipe_summaries: List[Dict[str, str]]) -> List[Dict[str, str]]: 73 | """ 74 | Rerank the provided recipe summaries by healthiness using a basic heuristic (e.g., mentions of "fried" or "sugar"). 75 | """ 76 | # Simplified healthiness scoring: fewer mentions of unhealthy terms score higher 77 | unhealthy_terms = ['fried', 'sugar', 'cream'] 78 | for recipe in recipe_summaries: 79 | recipe['health_score'] = sum(recipe['summary'].lower().count(term) for term in unhealthy_terms) 80 | ranked_recipes = sorted(recipe_summaries, key=lambda x: x['health_score']) 81 | return ranked_recipes 82 | 83 | def main(): 84 | logger.info("Starting recipe recommendation process...") 85 | recipe_names = brainstorm_recipes(ingredients) 86 | recipe_summaries = search_and_summarize_recipes(recipe_names) 87 | ranked_recipes = rerank_recipes_by_healthiness(recipe_summaries) 88 | 89 | for recipe in ranked_recipes: 90 | logger.info(f"Recipe Name: {recipe['name']}\nSummary: {recipe['summary']}\nLink: {recipe['url']}\n") 91 | 92 | if __name__ == "__main__": 93 | try: 94 | main() 95 | except Exception as e: 96 | logger.error(f"An error occurred during the recipe recommendation process: {str(e)}") -------------------------------------------------------------------------------- /experiment/testResults/v3/2-batch-embedding.py: -------------------------------------------------------------------------------- 1 | import os 2 | import requests 3 | import json 4 | 5 | jina_api_key = os.getenv("JINA_API_KEY") 6 | headers = { 7 | "Content-Type": "application/json", 8 | "Authorization": f"Bearer {jina_api_key}", 9 | "Accept": "application/json" 10 | } 11 | 12 | endpoint = "https://api.jina.ai/v1/embeddings" 13 | data = { 14 | "model": "jina-clip-v1", 15 | "input": [{"text": str(i)} for i in range(1, 101)] 16 | } 17 | 18 | response = requests.post(endpoint, json=data, headers=headers) 19 | embeddings = response.json() 20 | 21 | print(json.dumps(embeddings, indent=2)) -------------------------------------------------------------------------------- /experiment/testResults/v3/3-embedding for classification.py: -------------------------------------------------------------------------------- 1 | import os 2 | import requests 3 | 4 | # Read the API key from an environment variable 5 | api_key = os.getenv("JINA_API_KEY") 6 | 7 | # Define the endpoint and the headers for the API request 8 | endpoint = "https://api.jina.ai/v1/embeddings" 9 | headers = { 10 | "Content-Type": "application/json", 11 | "Authorization": f"Bearer {api_key}", 12 | "Accept": "application/json" 13 | } 14 | 15 | # Define the data/payload for the request 16 | data = { 17 | "model": "jina-clip-v1", 18 | "input": [ 19 | {"text": "Jina"} 20 | ] 21 | } 22 | 23 | # Make the POST request to get embeddings 24 | response = requests.post(endpoint, headers=headers, json=data) 25 | 26 | # Parse the response JSON and access the embeddings 27 | embeddings = response.json().get("data", [])[0]["embedding"] if response.status_code == 200 else [] 28 | 29 | print(embeddings) -------------------------------------------------------------------------------- /experiment/testResults/v3/4-embedding late chunking.py: -------------------------------------------------------------------------------- 1 | import requests 2 | import os 3 | 4 | # Reading the Jina API Key from environment variable 5 | api_key = os.getenv("JINA_API_KEY") 6 | 7 | # Setting the API endpoint for embedding generation 8 | endpoint = "https://api.jina.ai/v1/embeddings" 9 | 10 | # Preparing the headers with the Jina API Key and specifying JSON content type and accept headers 11 | headers = { 12 | "Content-Type": "application/json", 13 | "Authorization": f"Bearer {api_key}", 14 | "Accept": "application/json" 15 | } 16 | 17 | # Preparing the request data with model details and input text 18 | data = { 19 | "model": "jina-clip-v1", # Model for generating embeddings 20 | "input": [{"text": "Jina"}], # Text input for which embedding needs to be generated 21 | } 22 | 23 | # Sending the POST request to Jina AI API to generate embedding 24 | response = requests.post(endpoint, json=data, headers=headers) 25 | 26 | # Checking if the request was successful 27 | if response.status_code == 200: 28 | # Extracting embedding from response 29 | embedding = response.json().get("data")[0].get("embedding") 30 | print("Embedding for 'Jina':", embedding) 31 | else: 32 | print("Failed to generate embedding. Status code:", response.status_code) -------------------------------------------------------------------------------- /experiment/testResults/v3/5-embedding binary return type.py: -------------------------------------------------------------------------------- 1 | import requests 2 | import os 3 | 4 | JINA_API_KEY = os.getenv('JINA_API_KEY') 5 | 6 | endpoint = "https://api.jina.ai/v1/embeddings" 7 | headers = { 8 | "Content-Type": "application/json", 9 | "Authorization": f"Bearer {JINA_API_KEY}", 10 | "Accept": "application/json" 11 | } 12 | 13 | data = { 14 | "model": "jina-clip-v1", 15 | "input": [{"text": "Jina"}] 16 | } 17 | 18 | response = requests.post(endpoint, json=data, headers=headers) 19 | print(response.json()) -------------------------------------------------------------------------------- /experiment/testResults/v3/6-re-rank.py: -------------------------------------------------------------------------------- 1 | import os 2 | import requests 3 | 4 | # Environment variable for API key 5 | JINA_API_KEY = os.getenv("JINA_API_KEY") 6 | 7 | # Headers including Authorization token read from environment 8 | headers = { 9 | "Content-Type": "application/json", 10 | "Authorization": f"Bearer {JINA_API_KEY}", 11 | "Accept": "application/json" 12 | } 13 | 14 | # Data for the re-ranker API 15 | data = { 16 | "model": "jina-colbert-v2", 17 | "query": "Future of AI", 18 | "top_n": 5, 19 | "documents": [ 20 | "Jina", 21 | "Weaviate", 22 | "OpenAI", 23 | "Hugging Face", 24 | "Qdrant" 25 | ] 26 | } 27 | 28 | # Endpoint for the re-ranker API 29 | endpoint = "https://api.jina.ai/v1/rerank" 30 | 31 | # Make the request to the re-ranker API 32 | response = requests.post(endpoint, headers=headers, json=data) 33 | 34 | # Print the re-ranked results 35 | if response.status_code == 200: 36 | print("Re-ranked words for 'Future of AI':") 37 | for idx, result in enumerate(response.json()["data"]["results"], start=1): 38 | print(f"{idx}. {result['document']['text']} (Relevance score: {result['relevance_score']})") 39 | else: 40 | print("Failed to re-rank the words. Please check the inputs and try again.") -------------------------------------------------------------------------------- /experiment/testResults/v3/7-reader-grounding.py: -------------------------------------------------------------------------------- 1 | import os 2 | import requests 3 | 4 | # Fetch the API token from environment variables 5 | jina_api_key = os.environ.get("JINA_API_KEY") 6 | 7 | # Setup the header with authorization and content type 8 | headers = { 9 | "Authorization": f"Bearer {jina_api_key}", 10 | "Content-Type": "application/json", 11 | "Accept": "application/json" 12 | } 13 | 14 | # Define the statement to be checked 15 | statement = "The UK government has announced a new law that will require social media companies to verify the age of their users." 16 | 17 | # Setup the request data for g.reader fact-checker API 18 | data = { 19 | "query": statement 20 | } 21 | 22 | # Send the request to the g.reader API endpoint 23 | response = requests.post("https://g.jina.ai", json=data, headers=headers) 24 | 25 | if response.status_code == 200: 26 | # Parse the JSON response 27 | result = response.json() 28 | 29 | # Extract the factuality result, true or false 30 | is_statement_valid = result["data"]["result"] 31 | 32 | # Print out the validity of the statement 33 | print(f"The statement is: {'valid' if is_statement_valid else 'invalid'}") 34 | 35 | else: 36 | print("Failed to check the statement's validity.") -------------------------------------------------------------------------------- /experiment/testResults/v3/8-reader-grounding.py: -------------------------------------------------------------------------------- 1 | ```python 2 | import requests 3 | import os 4 | import umap 5 | import matplotlib.pyplot as plt 6 | import numpy as np 7 | 8 | # Set up authentication 9 | JINA_API_KEY = os.getenv("JINA_API_KEY") 10 | headers = { 11 | "Authorization": f"Bearer {JINA_API_KEY}", 12 | "Accept": "application/json" 13 | } 14 | 15 | # Select a dataset 16 | # For demonstration, let's assume we're working with a synthetic dataset provided below: 17 | data_points = [ 18 | {"text": "positive example 1", "label": "positive"}, 19 | {"text": "positive example 2", "label": "positive"}, 20 | {"text": "negative example 1", "label": "negative"}, 21 | {"text": "negative example 2", "label": "negative"}, 22 | # Assume we have about 1k of such examples evenly split between the two classes 23 | ] 24 | 25 | # Prepare inputs for embedding 26 | texts = [dp["text"] for dp in data_points] 27 | labels = np.array([0 if dp["label"] == "negative" else 1 for dp in data_points]) 28 | 29 | # Request embeddings with output_dim=2 30 | embedding_data_2d = { 31 | "model": "jina-clip-v1", 32 | "input": [{"text": text} for text in texts], 33 | "output_dim": 2 34 | } 35 | 36 | resp_2d = requests.post("https://api.jina.ai/v1/embeddings", json=embedding_data_2d, headers=headers) 37 | embeddings_2d = np.array([point["embedding"] for point in resp_2d.json()["data"]]) 38 | 39 | # Request embeddings with output_dim=1024 40 | embedding_data_1024d = { 41 | "model": "jina-clip-v1", 42 | "input": [{"text": text} for text in texts], 43 | "output_dim": 1024 44 | } 45 | 46 | resp_1024d = requests.post("https://api.jina.ai/v1/embeddings", json=embedding_data_1024d, headers=headers) 47 | embeddings_1024d = np.array([point["embedding"] for point in resp_1024d.json()["data"]]) 48 | 49 | # Reduce 1024d embeddings to 2D using UMAP 50 | reducer = umap.UMAP(n_neighbors=15, n_components=2, metric='cosine') 51 | embeddings_2d_umap = reducer.fit_transform(embeddings_1024d) 52 | 53 | # Visualization: Scatter plot 54 | fig, axes = plt.subplots(1, 2, figsize=(12, 6)) 55 | 56 | # Plot for 2D embeddings 57 | axes[0].scatter(embeddings_2d[labels==0, 0], embeddings_2d[labels==0, 1], color='red', label='Negative') 58 | axes[0].scatter(embeddings_2d[labels==1, 0], embeddings_2d[labels==1, 1], color='blue', label='Positive') 59 | axes[0].set_title('Original 2D Embeddings') 60 | axes[0].legend() 61 | axes[0].set_aspect('equal', 'box') 62 | 63 | # Plot for 2D reduced UMAP embeddings 64 | axes[1].scatter(embeddings_2d_umap[labels==0, 0], embeddings_2d_umap[labels==0, 1], color='red', label='Negative') 65 | axes[1].scatter(embeddings_2d_umap[labels==1, 0], embeddings_2d_umap[labels==1, 1], color='blue', label='Positive') 66 | axes[1].set_title('UMAP 2D Embeddings from 1024D') 67 | axes[1].legend() 68 | axes[1].set_aspect('equal', 'box') 69 | 70 | plt.show() 71 | ``` -------------------------------------------------------------------------------- /experiment/testResults/v3/9-books.py: -------------------------------------------------------------------------------- 1 | import json 2 | import os 3 | import requests 4 | from rich.console import Console 5 | from rich.traceback import install 6 | from dotenv import load_dotenv 7 | 8 | # Initialize rich console and traceback 9 | console = Console() 10 | install() 11 | 12 | # Load environment variables 13 | load_dotenv() 14 | 15 | # Jina API Key 16 | JINA_API_KEY = os.getenv('JINA_API_KEY') 17 | 18 | # Base headers for Jina API requests 19 | headers = { 20 | "Content-Type": "application/json", 21 | "Authorization": f"Bearer {JINA_API_KEY}", 22 | "Accept": "application/json" 23 | } 24 | 25 | # Authors and genres mapping based on author nature 26 | genres = { 27 | "Terry Pratchett": "Fantasy", 28 | "William Shakespeare": "Other" 29 | } 30 | 31 | # Function to classify genre based on book description 32 | def get_genre(description): 33 | data = { 34 | "model": "jina-embeddings-v3", 35 | "input": [ {"text": description} ], 36 | "labels": ["Science-fiction", "Fantasy", "Non-fiction", "Other"] 37 | } 38 | response = requests.post("https://api.jina.ai/v1/classify", json=data, headers=headers) 39 | if response.status_code == 200: 40 | # Return the genre with the highest score 41 | return max(response.json()['data'][0]['predictions'], key=lambda x: x['score'])['label'] 42 | else: 43 | console.log(f"Error classifying genre: {response.json()}") 44 | 45 | 46 | # Function to fetch and process books for an author 47 | def fetch_books_for_author(author): 48 | url = f"https://www.googleapis.com/books/v1/volumes?q=inauthor:\"{author}\"&langRestrict=en&maxResults=30&printType=books&orderBy=newest" 49 | response = requests.get(url) 50 | if response.status_code == 200: 51 | books_data = response.json().get('items', []) 52 | processed_books = [] 53 | for book in books_data[:10]: # Limit to latest 10 books 54 | book_info = book['volumeInfo'] 55 | title = book_info.get('title', 'N/A') 56 | published_date = book_info.get('publishedDate', 'N/A') 57 | description = book_info.get('description', 'N/A') 58 | # Use predefined genre based on the author; this could be enhanced by analyzing the description 59 | genre = genres[author] 60 | 61 | # Generate embedding 62 | embedding_data = { 63 | "model": "jina-clip-v1", 64 | "input": [{"text": description}] 65 | } 66 | embedding_response = requests.post("https://api.jina.ai/v1/embeddings", json=embedding_data, headers=headers) 67 | if embedding_response.status_code == 200: 68 | embedding = embedding_response.json()['data'][0]['embedding'] 69 | console.log(f"Embedding generated for {title}") 70 | else: 71 | console.log(f"Failed to generate embedding for {title}: {embedding_response.json()}") 72 | embedding = [] 73 | 74 | processed_books.append({ 75 | "author": author, 76 | "title": title, 77 | "published_date": published_date, 78 | "description": description, 79 | "genre": genre, 80 | "embedding": embedding 81 | }) 82 | return processed_books 83 | else: 84 | console.log(f"Failed to fetch books for {author}: {response.json()}") 85 | return [] 86 | 87 | # Main function to process authors and generate files 88 | def main(): 89 | authors = ["Terry Pratchett", "William Shakespeare"] 90 | all_books = [] 91 | for author in authors: 92 | books = fetch_books_for_author(author) 93 | all_books.extend(books) 94 | 95 | # Write to books-embeddings.json including embeddings 96 | with open("books-embeddings.json", 'w') as file: 97 | json.dump(all_books, file, indent=4) 98 | console.log("books-embeddings.json has been written successfully.") 99 | 100 | # Exclude embeddings for books.json 101 | for book in all_books: 102 | book.pop('embedding', None) 103 | 104 | # Write to books.json excluding embeddings 105 | with open("books.json", 'w') as file: 106 | json.dump(all_books, file, indent=4) 107 | console.log("books.json has been written successfully.") 108 | 109 | main() -------------------------------------------------------------------------------- /experiment/testResults/v4/0-hackernews.py: -------------------------------------------------------------------------------- 1 | import os 2 | import requests 3 | import matplotlib.pyplot as plt 4 | import umap 5 | import numpy as np 6 | 7 | # Get your Jina AI API key for free: https://jina.ai/?sui=apikey 8 | JINA_API_KEY = os.getenv("JINA_API_KEY") 9 | 10 | headers = { 11 | "Authorization": f"Bearer {JINA_API_KEY}", 12 | "Accept": "application/json", 13 | "Content-Type": "application/json", 14 | } 15 | 16 | def get_hn_frontpage_sentences(): 17 | url = "https://hacker-news.firebaseio.com/v0/topstories.json" 18 | top_stories = requests.get(url).json()[:10] # Limiting to top 10 stories for brevity 19 | sentences = [] 20 | 21 | for story_id in top_stories: 22 | story_url = f"https://hacker-news.firebaseio.com/v0/item/{story_id}.json" 23 | story_data = requests.get(story_url).json() 24 | sentences.append(story_data["title"]) # Assuming we're only interested in titles 25 | 26 | return sentences 27 | 28 | def get_embeddings(texts): 29 | embeddings_api_url = "https://api.jina.ai/v1/embeddings" 30 | data = { 31 | "model": "jina-clip-v1", 32 | "input": texts, 33 | } 34 | response = requests.post(embeddings_api_url, headers=headers, json=data).json() 35 | embeddings = [item["embedding"] for item in response["data"]] 36 | return embeddings 37 | 38 | sentences = get_hn_frontpage_sentences() 39 | embeddings = get_embeddings(sentences) 40 | 41 | embeddings_np = np.array(embeddings) 42 | reducer = umap.UMAP() 43 | umap_emb = reducer.fit_transform(embeddings_np) 44 | 45 | plt.figure(figsize=(12, 8)) 46 | plt.scatter(umap_emb[:, 0], umap_emb[:, 1]) 47 | for i, sentence in enumerate(sentences): 48 | plt.text(umap_emb[i, 0], umap_emb[i, 1], sentence[:30], fontsize=9) 49 | plt.title("UMAP visualization of HackerNews Frontpage Sentences") 50 | plt.show() -------------------------------------------------------------------------------- /experiment/testResults/v4/1-image-rerank.py: -------------------------------------------------------------------------------- 1 | import os 2 | import requests 3 | 4 | # Get your Jina AI API key for free: https://jina.ai/?sui=apikey 5 | JINA_API_KEY = os.getenv("JINA_API_KEY") 6 | 7 | def classify_images(image_paths, labels): 8 | headers = { 9 | "Authorization": f"Bearer {JINA_API_KEY}", 10 | "Accept": "application/json" 11 | } 12 | url = "https://api.jina.ai/v1/classify" 13 | predictions = [] 14 | 15 | for image_path in image_paths: 16 | with open(image_path, "rb") as f: 17 | image_bytes = f.read() 18 | base64_image = base64.b64encode(image_bytes).decode("utf-8") 19 | 20 | body = { 21 | "model": "jina-clip-v1", 22 | "input": [{"image": base64_image}], 23 | "labels": labels 24 | } 25 | 26 | response = requests.post(url, json=body, headers=headers) 27 | 28 | if response.status_code == 200: 29 | predictions.append(response.json()['data'][0]['prediction']) 30 | else: 31 | predictions.append("Error") 32 | 33 | return predictions 34 | 35 | 36 | def main(image_paths, labels): 37 | predictions = classify_images(image_paths, labels) 38 | for path, prediction in zip(image_paths, predictions): 39 | print(f"{path}: {prediction}") 40 | 41 | if __name__ == "__main__": 42 | # Example usage 43 | images = ["./path/to/image1.jpg", "./path/to/image2.jpg"] 44 | labels = ["animal", "vehicle", "scenery", "food"] 45 | main(images, labels) -------------------------------------------------------------------------------- /experiment/testResults/v4/10-docsqa.py: -------------------------------------------------------------------------------- 1 | import json 2 | import requests 3 | import os 4 | 5 | # Get your Jina AI API key for free: https://jina.ai/?sui=apikey 6 | JINA_API_KEY = os.getenv("JINA_API_KEY") 7 | HEADERS = { 8 | "Authorization": f"Bearer {JINA_API_KEY}", 9 | "Accept": "application/json", 10 | "Content-Type": "application/json" 11 | } 12 | 13 | def read(url): 14 | try: 15 | response = requests.post( 16 | "https://r.jina.ai/", 17 | headers=HEADERS, 18 | json={"url": url} 19 | ) 20 | response.raise_for_status() 21 | data = response.json() 22 | return data["data"]["content"] 23 | except requests.exceptions.RequestException as e: 24 | print(f"Error fetching the content: {e}") 25 | return None 26 | 27 | def segment(content): 28 | try: 29 | response = requests.post( 30 | "https://segment.jina.ai/", 31 | headers=HEADERS, 32 | json={"content": content, "return_chunks": True} 33 | ) 34 | response.raise_for_status() 35 | data = response.json() 36 | return data["chunks"] 37 | except requests.exceptions.RequestException as e: 38 | print(f"Error segmenting the content: {e}") 39 | return None 40 | 41 | def rerank(query, documents): 42 | try: 43 | response = requests.post( 44 | "https://api.jina.ai/v1/rerank", 45 | headers=HEADERS, 46 | json={"model": "jina-reranker-v2-base-multilingual", "query": query, "documents": documents} 47 | ) 48 | response.raise_for_status() 49 | data = response.json() 50 | return data["results"] 51 | except requests.exceptions.RequestException as e: 52 | print(f"Error reranking the documents: {e}") 53 | return None 54 | 55 | def main(): 56 | # Reading web content 57 | content_solidpython = read("https://github.com/jeff-dh/SolidPython") 58 | content_wiki = read("https://github.com/jeff-dh/SolidPython/wiki") 59 | 60 | # this is a placeholder for actual scraping and indexing process which we can't perform here directly 61 | index_content = ["Sample index content 1 from SolidPython repo", "Sample index content 2 from SolidPython wiki"] 62 | 63 | # Assuming content is segmented and indexed, now prompting user for a question 64 | question = input("What would you like to know about SolidPython? ") 65 | 66 | # For simplicity, instead of matching question with indexed segments, 67 | # I'll just simulate finding top 3 segments from index 68 | top_segments = segment("\n\n".join(index_content))[:3] # Simulate top 3 segments 69 | 70 | # Now assuming we have top 3 segments, let's use rerank to find the most relevant 71 | # In a real scenario, you'll match these against the question or pass directly to LLM 72 | # Here, reranking is more for demonstration 73 | reranked_segments = rerank(question, top_segments) 74 | 75 | # Constructing the prompt for LLM (Large Language Model) 76 | llm_prompt = f"Based on these segments:\n\n- {reranked_segments[0]['document']['text']}\n- {reranked_segments[1]['document']['text']}\n- {reranked_segments[2]['document']['text']}\n\nAnswer the question: {question}" 77 | 78 | # Normally we would now call an LLM API with this prompt to generate an answer, 79 | # but since we don't have an actual LLM endpoint, we'll print the prompt for now 80 | print("\nPrompt for LLM:\n") 81 | print(llm_prompt) 82 | 83 | 84 | if __name__ == "__main__": 85 | main() -------------------------------------------------------------------------------- /experiment/testResults/v4/11-papers.py: -------------------------------------------------------------------------------- 1 | import os 2 | import requests 3 | from rich.console import Console 4 | 5 | # Get your Jina AI API key for free: https://jina.ai/?sui=apikey 6 | JINA_API_KEY = os.getenv("JINA_API_KEY") 7 | HEADERS = { 8 | "Authorization": f"Bearer {JINA_API_KEY}", 9 | "Accept": "application/json", 10 | "Content-Type": "application/json" 11 | } 12 | 13 | console = Console() 14 | 15 | def search_papers(term="embeddings", max_results=3): 16 | search_url = "https://s.jina.ai/" 17 | body = { 18 | "q": term, 19 | "options": "Text" 20 | } 21 | try: 22 | response = requests.post(search_url, json=body, headers=HEADERS) 23 | response.raise_for_status() 24 | data = response.json().get("data", [])[:max_results] 25 | papers = [{"title": item["title"], "url": item["url"]} for item in data] 26 | return papers 27 | except Exception as e: 28 | console.log(f"[bold red]Error searching for papers: {e}[/bold red]") 29 | return [] 30 | 31 | def scrape_paper(paper): 32 | reader_url = "https://r.jina.ai/" 33 | body = { 34 | "url": paper["url"] 35 | } 36 | try: 37 | response = requests.post(reader_url, json=body, headers=HEADERS) 38 | response.raise_for_status() 39 | data = response.json()["data"] 40 | return {"title": data["title"], "content": data["content"]} 41 | except Exception as e: 42 | console.log(f"[bold red]Error scraping paper: {e}[/bold red]") 43 | return None 44 | 45 | def segment_content(content): 46 | segment_url = "https://segment.jina.ai/" 47 | body = { 48 | "content": content, 49 | "return_chunks": True 50 | } 51 | try: 52 | response = requests.post(segment_url, json=body, headers=HEADERS) 53 | response.raise_for_status() 54 | data = response.json() 55 | return data.get("chunks") 56 | except Exception as e: 57 | console.log(f"[bold red]Error segmenting content: {e}[/bold red]") 58 | return [] 59 | 60 | def generate_embeddings(segments): 61 | embeddings_url = "https://api.jina.ai/v1/embeddings" 62 | body = { 63 | "model": "jina-embeddings-v3", 64 | "input": segments, 65 | "task": "retrieval.passage" 66 | } 67 | try: 68 | response = requests.post(embeddings_url, json=body, headers=HEADERS) 69 | response.raise_for_status() 70 | embeds = response.json().get("data", []) 71 | return [embed for embed in embeds] 72 | except Exception as e: 73 | console.log(f"[bold red]Error generating embeddings: {e}[/bold red]") 74 | return [] 75 | 76 | def search_within_papers(query, papers_embeddings): 77 | embeddings_url = "https://api.jina.ai/v1/embeddings" 78 | body = { 79 | "model": "jina-embeddings-v3", 80 | "input": [query], 81 | "task": "retrieval.query" 82 | } 83 | matching_passages = [] 84 | try: 85 | query_embed_response = requests.post(embeddings_url, json=body, headers=HEADERS) 86 | query_embed_response.raise_for_status() 87 | query_embed = query_embed_response.json().get("data", [])[0]["embedding"] 88 | 89 | for paper, segments_embeddings in papers_embeddings.items(): 90 | for segment, embed in segments_embeddings: 91 | # Example condition for similarity (this should be an actual embedding comparison calculation) 92 | if query_embed[:5] == embed["embedding"][:5]: # Placeholder similarity check 93 | matching_passages.append((paper, segment)) 94 | return matching_passages 95 | except Exception as e: 96 | console.log(f"[bold red]Error searching within papers: {e}[/bold red]") 97 | return [] 98 | 99 | def main(): 100 | papers = search_papers() 101 | if papers: 102 | papers_contents = {} 103 | papers_embeddings = {} 104 | for paper in papers: 105 | console.log(f"Scraping paper: [bold green]{paper['title']}[/bold green]") 106 | content = scrape_paper(paper) 107 | if content: 108 | segments = segment_content(content["content"]) 109 | embeddings = generate_embeddings(segments) 110 | papers_contents[paper["title"]] = content 111 | papers_embeddings[paper["title"]] = zip(segments, embeddings) 112 | 113 | query = console.input("Enter your search query: ") 114 | matches = search_within_papers(query, papers_embeddings) 115 | for title, segment in matches: 116 | console.log(f"Match found in [bold]{title}[/bold]: {segment}") 117 | 118 | if __name__ == "__main__": 119 | main() -------------------------------------------------------------------------------- /experiment/testResults/v4/12-recipes.py: -------------------------------------------------------------------------------- 1 | import os 2 | import requests 3 | 4 | # Get your Jina AI API key for free: https://jina.ai/?sui=apikey 5 | JINA_API_KEY = os.environ['JINA_API_KEY'] 6 | 7 | def get_headers(): 8 | """ 9 | Prepare the headers for authorization and accept JSON responses. 10 | """ 11 | return { 12 | 'Authorization': f'Bearer {JINA_API_KEY}', 13 | 'Accept': 'application/json' 14 | } 15 | 16 | def search_recipes(ingredients): 17 | """ 18 | Search for recipes using specified ingredients. 19 | """ 20 | query = f'Recipes with {", ".join(ingredients)}' 21 | url = 'https://s.jina.ai/' 22 | headers = get_headers() 23 | payload = { 24 | 'q': query, 25 | 'options': 'Text' 26 | } 27 | response = requests.post(url, json=payload, headers=headers) 28 | if response.status_code == 200: 29 | return response.json()['data'] 30 | else: 31 | print("Error searching for recipes:", response.json()) 32 | return [] 33 | 34 | def summarize_recipe(url): 35 | """ 36 | Summarize the specified recipe from a URL. 37 | """ 38 | summarizer_url = 'https://r.jina.ai/' 39 | headers = get_headers() 40 | payload = { 41 | 'url': url 42 | } 43 | response = requests.post(summarizer_url, json=payload, headers=headers) 44 | if response.status_code == 200: 45 | return response.json()['data']['content'] 46 | else: 47 | print("Error summarizing recipe:", response.json()) 48 | return "" 49 | 50 | def rank_recipes_by_healthiness(recipes): 51 | """ 52 | Re-rank recipes by their healthiness based on ingredients and content. 53 | NOT IMPLEMENTABLE with Jina AI's current API set as there's no direct healthiness rating API. 54 | Placeholder function for potential future capabilities. 55 | """ 56 | # A placeholder implementation as direct recipe healthiness ranking isn't available. 57 | # One might use predefined criteria or look for specific health-related words/phrases instead. 58 | return recipes 59 | 60 | def main(): 61 | ingredients = ["Onion", "Chickpeas", "Tinned chopped tomatoes", "Chicken thighs", "EVOO", "S+P", "Cumin", "Garlic", "Ginger", "Italian seasoning", "Chilli flakes", "Sweet potato", "Peanut butter", "Chicken stock", "Milk", "Sugar"] 62 | 63 | recipe_links = search_recipes(ingredients) 64 | if not recipe_links: 65 | print("No recipes found.") 66 | return 67 | 68 | for recipe in recipe_links: 69 | summary = summarize_recipe(recipe['url']) 70 | print(f"Recipe Name: {recipe['title']}\nSummary: {summary}\nLink: {recipe['url']}\n") 71 | # Note: The summary could be empty if there was an error. 72 | 73 | if __name__ == "__main__": 74 | main() -------------------------------------------------------------------------------- /experiment/testResults/v4/2-batch-embedding.py: -------------------------------------------------------------------------------- 1 | import requests 2 | import os 3 | import json 4 | 5 | # Get your Jina AI API key for free: https://jina.ai/?sui=apikey 6 | api_key = os.getenv('JINA_API_KEY') 7 | headers = { 8 | "Authorization": f"Bearer {api_key}", 9 | "Content-Type": "application/json", 10 | "Accept": "application/json" 11 | } 12 | 13 | def generate_embeddings(text_data): 14 | url = "https://api.jina.ai/v1/embeddings" 15 | payload = { 16 | "model": "jina-embeddings-v3", 17 | "input": text_data, 18 | "embedding_type": "float" 19 | } 20 | response = requests.post(url, headers=headers, data=json.dumps(payload)) 21 | if response.status_code == 200: 22 | return response.json() 23 | else: 24 | print("Error while generating embeddings:", response.json()) 25 | 26 | def main(): 27 | numbers_in_text = [str(n) for n in range(1, 101)] 28 | embeddings = generate_embeddings(numbers_in_text) 29 | if embeddings: 30 | # Process or save your embeddings here 31 | print(embeddings) 32 | 33 | if __name__ == "__main__": 34 | main() -------------------------------------------------------------------------------- /experiment/testResults/v4/3-embedding for classification.py: -------------------------------------------------------------------------------- 1 | import os 2 | import requests 3 | import json 4 | 5 | # Get your Jina AI API key for free: https://jina.ai/?sui=apikey 6 | JINA_API_KEY = os.getenv("JINA_API_KEY") 7 | 8 | def generate_embedding(text): 9 | url = "https://api.jina.ai/v1/embeddings" 10 | headers = { 11 | "Authorization": f"Bearer {JINA_API_KEY}", 12 | "Content-Type": "application/json", 13 | "Accept": "application/json", 14 | } 15 | data = { 16 | "model": "jina-embeddings-v3", 17 | "input": [text], 18 | "embedding_type": "float", 19 | "task": "classification" 20 | } 21 | response = requests.post(url, headers=headers, data=json.dumps(data)) 22 | if response.status_code == 200: 23 | return response.json() 24 | else: 25 | print("Failed to generate embedding:", response.text) 26 | return None 27 | 28 | # Example usage 29 | text = "Jina" 30 | embedding = generate_embedding(text) 31 | print(embedding) -------------------------------------------------------------------------------- /experiment/testResults/v4/4-embedding late chunking.py: -------------------------------------------------------------------------------- 1 | import os 2 | import requests 3 | 4 | # Get your Jina AI API key for free: https://jina.ai/?sui=apikey 5 | API_KEY = os.getenv("JINA_API_KEY") 6 | headers = { 7 | "Authorization": f"Bearer {API_KEY}", 8 | "Accept": "application/json", 9 | "Content-Type": "application/json" 10 | } 11 | 12 | def generate_embedding(input_text): 13 | payload = { 14 | "model": "jina-embeddings-v3", 15 | "input": [input_text], 16 | "late_chunking": True 17 | } 18 | response = requests.post("https://api.jina.ai/v1/embeddings", headers=headers, json=payload) 19 | if response.status_code == 200: 20 | return response.json() 21 | else: 22 | return response.text 23 | 24 | # Example usage 25 | embedding_response = generate_embedding("Jina") 26 | print(embedding_response) -------------------------------------------------------------------------------- /experiment/testResults/v4/5-embedding binary return type.py: -------------------------------------------------------------------------------- 1 | import os 2 | import requests 3 | import json 4 | 5 | # Get your Jina AI API key for free: https://jina.ai/?sui=apikey 6 | JINA_API_KEY = os.getenv("JINA_API_KEY") 7 | 8 | def generate_embedding(input_text): 9 | headers = { 10 | "Authorization": f"Bearer {JINA_API_KEY}", 11 | "Content-Type": "application/json", 12 | "Accept": "application/json" 13 | } 14 | payload = { 15 | "model": "jina-embeddings-v3", 16 | "input": [input_text], 17 | "embedding_type": "binary" 18 | } 19 | response = requests.post("https://api.jina.ai/v1/embeddings", headers=headers, data=json.dumps(payload)) 20 | if response.status_code == 200: 21 | return response.json() 22 | else: 23 | print(f"Error: {response.json()}") 24 | 25 | # Example usage 26 | if __name__ == "__main__": 27 | input_text = "Jina" 28 | result = generate_embedding(input_text) 29 | print(result) -------------------------------------------------------------------------------- /experiment/testResults/v4/6-re-rank.py: -------------------------------------------------------------------------------- 1 | import os 2 | import requests 3 | 4 | # Get your Jina AI API key for free: https://jina.ai/?sui=apikey 5 | JINA_API_KEY = os.getenv("JINA_API_KEY") 6 | headers = { 7 | "Authorization": f"Bearer {JINA_API_KEY}", 8 | "Accept": "application/json" 9 | } 10 | 11 | def rerank_documents(query, documents): 12 | url = "https://api.jina.ai/v1/rerank" 13 | data = { 14 | "model": "jina-reranker-v2-base-multilingual", 15 | "query": query, 16 | "documents": documents 17 | } 18 | 19 | response = requests.post(url, json=data, headers=headers) 20 | if response.status_code == 200: 21 | return response.json()["results"] 22 | else: 23 | raise Exception(f"Error in rerank_documents: {response.json()}") 24 | 25 | def main(): 26 | query = "Future of AI" 27 | documents = ["Jina", "Weaviate", "OpenAI", "Hugging Face", "Qdrant"] 28 | try: 29 | reranked_documents = rerank_documents(query, documents) 30 | print("Re-ranked documents based on the query 'Future of AI':") 31 | for doc in reranked_documents: 32 | print(f"Index: {doc['index']}, Text: {doc['document']['text']}, Score: {doc['relevance_score']}") 33 | except Exception as e: 34 | print(e) 35 | 36 | if __name__ == "__main__": 37 | main() -------------------------------------------------------------------------------- /experiment/testResults/v4/7-reader-grounding.py: -------------------------------------------------------------------------------- 1 | import os 2 | import requests 3 | 4 | # Get your Jina AI API key for free: https://jina.ai/?sui=apikey 5 | JINA_API_KEY = os.getenv("JINA_API_KEY") 6 | HEADER = { 7 | "Authorization": f"Bearer {JINA_API_KEY}", 8 | "Accept": "application/json", 9 | "Content-Type": "application/json" 10 | } 11 | 12 | def verify_statement(statement): 13 | url = "https://g.jina.ai/" 14 | payload = {"statement": statement} 15 | try: 16 | response = requests.post(url, json=payload, headers=HEADER) 17 | if response.status_code == 200: 18 | data = response.json() 19 | return data 20 | else: 21 | return {"error": "Failed to verify the statement due to API error."} 22 | except Exception as e: 23 | return {"error": str(e)} 24 | 25 | def main(): 26 | statement = 'The UK government has announced a new law that will require social media companies to verify the age of their users.' 27 | result = verify_statement(statement) 28 | print(result) 29 | 30 | if __name__ == "__main__": 31 | main() -------------------------------------------------------------------------------- /experiment/testResults/v4/8-reader-grounding.py: -------------------------------------------------------------------------------- 1 | import os 2 | import requests 3 | from sklearn.decomposition import PCA 4 | import matplotlib.pyplot as plt 5 | import numpy as np 6 | import umap 7 | 8 | # Get your Jina AI API key for free: https://jina.ai/?sui=apikey 9 | jina_api_key = os.getenv("JINA_API_KEY") 10 | headers = { 11 | "Authorization": f"Bearer {jina_api_key}", 12 | "Accept": "application/json", 13 | } 14 | 15 | def fetch_embedding(data, output_dim=None): 16 | """Fetch embeddings for the given data.""" 17 | body = { 18 | "model": "jina-embeddings-v3", 19 | "input": data, 20 | "task": "separation", 21 | } 22 | if output_dim is not None: 23 | body["dimensions"] = output_dim 24 | response = requests.post("https://api.jina.ai/v1/embeddings", headers=headers, json=body) 25 | if response.status_code == 200: 26 | return np.array([res["embedding"] for res in response.json()["data"]]) 27 | else: 28 | raise Exception(f"Failed to fetch embeddings: {response.json()}") 29 | 30 | def generate_plot(data, labels, title): 31 | """Generate and save a plot.""" 32 | plt.figure() 33 | classes = list(set(labels)) 34 | for _class in classes: 35 | idxs = [i for i, l in enumerate(labels) if l == _class] 36 | plt.scatter(data[idxs, 0], data[idxs, 1], label=f"Class {_class}") 37 | 38 | plt.title(title) 39 | plt.legend() 40 | plt.axis('square') 41 | plt.show() 42 | 43 | # Dummy data and labels 44 | data = ["text1"] * 500 + ["text2"] * 500 45 | labels = [0] * 500 + [1] * 500 46 | 47 | # Fetching embeddings with output_dim=2 48 | embeddings_dim2 = fetch_embedding(data, output_dim=2) 49 | generate_plot(embeddings_dim2, labels, "Embeddings with output_dim=2") 50 | 51 | # Fetching embeddings without specifying output_dim (default) 52 | embeddings_high_dim = fetch_embedding(data) 53 | 54 | # Reducing dimensionality to 2D using UMAP 55 | reducer = umap.UMAP(n_neighbors=15, min_dist=0.1, n_components=2, metric='euclidean') 56 | umap_embeds = reducer.fit_transform(embeddings_high_dim) 57 | 58 | # Generating UMAP reduced plot 59 | generate_plot(umap_embeds, labels, "UMAP reduced embeddings") 60 | 61 | # Note: Actual implementation would require real dataset instead of dummy data/labels. -------------------------------------------------------------------------------- /experiment/testResults/v4/9-books.py: -------------------------------------------------------------------------------- 1 | ```python 2 | import os 3 | import requests 4 | import json 5 | from rich.console import Console 6 | from rich.logging import RichHandler 7 | import logging 8 | 9 | # Setup rich logging 10 | console = Console() 11 | logging.basicConfig(level="INFO", format="%(message)s", datefmt="[%X]", handlers=[RichHandler()]) 12 | logger = logging.getLogger("rich") 13 | 14 | # Get your Jina AI API key for free: https://jina.ai/?sui=apikey 15 | JINA_API_KEY = os.getenv("JINA_API_KEY") 16 | HEADERS = { 17 | "Authorization": f"Bearer {JINA_API_KEY}", 18 | "Accept": "application/json" 19 | } 20 | 21 | def generate_embeddings(description): 22 | data = { 23 | "model": "jina-embeddings-v3", 24 | "input": [description], 25 | "task": "retrieval.passage", 26 | "late_chunking": True 27 | } 28 | try: 29 | response = requests.post("https://api.jina.ai/v1/embeddings", json=data, headers=HEADERS) 30 | response.raise_for_status() 31 | embedding = response.json()['data'][0]['embedding'] 32 | return embedding 33 | except requests.exceptions.HTTPError as err: 34 | logger.error(f"Error generating embedding: {err}") 35 | return None 36 | 37 | def classify_genre(description): 38 | # For simplicity, genre classification is done based on keywords. This should ideally be replaced with a more robust method. 39 | if any(word in description.lower() for word in ["discworld", "magic", "wizard", "fantasy"]): 40 | return "Fantasy" 41 | elif any(word in description.lower() for word in ["science", "space", "future", "sci-fi"]): 42 | return "Science-fiction" 43 | elif "non-fiction" in description.lower(): 44 | return "Non-fiction" 45 | else: 46 | return "Other" 47 | 48 | def fetch_books_by_author(author): 49 | books = [] 50 | url = f"https://www.googleapis.com/books/v1/volumes?q=inauthor:%22{author}%22&langRestrict=en&maxResults=30&printType=books&orderBy=newest" 51 | try: 52 | response = requests.get(url) 53 | response.raise_for_status() 54 | items = response.json().get("items", []) 55 | seen_titles = set() 56 | for item in items: 57 | if len(books) >= 10: 58 | break 59 | info = item.get("volumeInfo", {}) 60 | title = info.get("title", "") 61 | published_date = info.get("publishedDate", "") 62 | description = info.get("description", "") 63 | 64 | if title not in seen_titles: 65 | seen_titles.add(title) 66 | genre = classify_genre(description) 67 | embedding = generate_embeddings(description) 68 | 69 | books.append({ 70 | "author": author, 71 | "title": title, 72 | "published_date": published_date, 73 | "description": description, 74 | "genre": genre, 75 | "embedding": embedding 76 | }) 77 | 78 | except requests.exceptions.HTTPError as err: 79 | logger.error(f"Failed to fetch books for {author}: {err}") 80 | 81 | return books 82 | 83 | def main(): 84 | authors = ["Terry Pratchett", "William Shakespeare"] 85 | all_books = [] 86 | for author in authors: 87 | logger.info(f"Fetching books for {author}") 88 | books = fetch_books_by_author(author) 89 | all_books.extend(books) 90 | 91 | with open("books.json", "w") as f: 92 | json_books = [book for book in all_books if book.get("embedding") is None] 93 | json.dump(json_books, f, indent=4) 94 | 95 | with open("books-embeddings.json", "w") as f: 96 | json.dump(all_books, f, indent=4) 97 | 98 | logger.info("Books and their embeddings have been saved.") 99 | 100 | if __name__ == "__main__": 101 | main() 102 | ``` -------------------------------------------------------------------------------- /headers.json: -------------------------------------------------------------------------------- 1 | { 2 | "x-content-type-options": "nosniff", 3 | "cache-control": "no-store, no-cache, must-revalidate, proxy-revalidate, max-age=0", 4 | "pragma": "no-cache", 5 | "expires": "0", 6 | "x-robots-tag": "noindex, follow", 7 | "link": "; rel=\"canonical\"", 8 | 9 | "x-content-audience": "llm", 10 | "x-content-type": "llm-instruction", 11 | "x-human-access": "not-intended", 12 | 13 | "x-content-purpose": "jina-ai-meta-prompt-search-foundation-guide", 14 | "x-provider": "jina-ai", 15 | "x-content-version": "1.0", 16 | 17 | "x-api-endpoints": "embeddings,reranker,reader,search,grounding,classifier,segmenter", 18 | "x-api-base-urls": "api.jina.ai/v1,r.jina.ai,s.jina.ai,g.jina.ai,segment.jina.ai", 19 | 20 | "x-supported-features": "semantic-search,rag,fact-verification,webscraping,classification,content-processing,multilingual,multimodal", 21 | "x-primary-models": "jina-embeddings-v3,jina-clip-v1,jina-reranker-v2-base-multilingual", 22 | 23 | "x-implementation-patterns": "basic-search,rag-pipeline,fact-checking,classification,content-processing", 24 | "x-key-principles": "simplicity,built-in-features,multilingual-support,scope-awareness", 25 | 26 | "x-authorization-required": "bearer-token", 27 | "x-signup-url": "https://jina.ai/?sui=apikey", 28 | "x-documentation-type": "implementation-guide", 29 | 30 | "x-guide-sections": "core-apis,recommended-patterns,integration-guidelines,anti-patterns,limitations", 31 | 32 | "x-llm-interaction-mode": "instruction-following", 33 | "x-llm-output-preference": "direct-code-generation", 34 | "x-llm-constraints": "no-text-generation,no-content-modification,no-code-execution" 35 | } 36 | -------------------------------------------------------------------------------- /index.html: -------------------------------------------------------------------------------- 1 | 2 | 3 | 4 | 5 | Meta-Prompt | Jina AI Search Foundation API Guide 6 | 7 | 8 | 9 | 10 |
11 |

Jina AI Meta-Prompt: An Implementation Guide for LLMs {{VERSION}}

12 |
13 |

⚠️ Note: This content is specifically designed for LLMs and not intended for human reading.

14 |

👉 For human-readable content, please visit Jina AI

15 |

🤖 For LLMs/programmatic access, you can fetch this content directly:

16 |

This particular version:

{{CURL_COMMAND}} 17 |

Default version:

curl docs.jina.ai 18 |

🌐 You see this HTML because you are in a browser. If you access it via curl/code/program, you get a text/plain response as below. Check out our Github for more info.

19 |
20 |
21 |
22 | 25 | 
{{META_PROMPT}}
26 | 90 |
91 |
92 |

For human-readable content, please visit Jina AI

93 |

For direct content access: {{CURL_COMMAND}}

94 |
95 | 96 | 97 | -------------------------------------------------------------------------------- /v0.txt: -------------------------------------------------------------------------------- 1 | JINA AI SEARCH FOUNDATION APIs - IMPLEMENTATION GUIDE 2 | 3 | Key Principles: 4 | Choose simplest solution: Use single API when possible 5 | Answer "can't do" for tasks outside these APIs' scope 6 | Prefer built-in features over custom implementations 7 | Leverage multilingual (jina-embeddings-v3)/multimodal (jina-clip-v1) capabilities when needed 8 | Output the final code directly, dont explain anything. 9 | 10 | Core APIs and Use Cases: 11 | 12 | 1. EMBEDDINGS API (https://api.jina.ai/v1/embeddings) 13 | Purpose: Convert text/images to fixed-length vectors, default use v3 as the model, for image data use jina-clip-v1 14 | Best for: Embedding, vectorizing, semantic search, similarity matching, clustering 15 | Request: 16 | curl -X 'POST' \ 17 | 'http://api.jina.ai/v1/embeddings' \ 18 | -H 'accept: application/json' \ 19 | -H 'Authorization: Bearer YOUR_BEARER_TOKEN' \ 20 | -H 'Content-Type: application/json' \ 21 | -d '{ 22 | "model": "jina-clip-v1", 23 | "input": ["Input sent1", "Input sent2", "Input sent3", ...], 24 | "embedding_type": "float", 25 | "task": "retrieval.query", 26 | "dimensions": 768, 27 | "normalized": false, 28 | "late_chunking": false 29 | }' 30 | Fields: 31 | model: (required) Model ID. Values: "jina-clip-v1", "jina-embeddings-v3" 32 | input: (required) List of texts to embed 33 | embedding_type: (optional, default: float) Format. Values: "float", "base64", "binary", "ubinary" 34 | task: (optional) Intended use. Values: "retrieval.query", "retrieval.passage", "text-matching", "classification", "separation" 35 | dimensions: (optional) Output size 36 | normalized: (optional, default: false) L2 normalization 37 | late_chunking: (optional, default: false) Late chunking flag 38 | Response: 39 | { 40 | "model": "jina-clip-v1", 41 | "object": "list", 42 | "data": [ 43 | { 44 | "index": 0, 45 | "embedding": [0.1, 0.2, 0.3], 46 | "object": "embedding" 47 | } 48 | ], 49 | "usage": { 50 | "total_tokens": 15 51 | } 52 | } 53 | 54 | 3. RERANKER API (https://api.jina.ai/v1/rerank) 55 | Purpose: Improve search result relevancy 56 | Best for: Refining search results, RAG accuracy 57 | Request: 58 | curl -X 'POST' \ 59 | 'http://api.jina.ai/v1/rerank' \ 60 | -H 'accept: application/json' \ 61 | -H 'Authorization: Bearer YOUR_ACCESS_TOKEN' \ 62 | -H 'Content-Type: application/json' \ 63 | -d '{ 64 | "model": "jina-reranker-v2-base-multilingual", 65 | "query": "Search query", 66 | "documents": ["Document 1", "Document 2", "Document 3", ...], 67 | "top_n": 2, 68 | "return_documents": true 69 | }' 70 | Fields: 71 | model: (required) Model ID 72 | query: (required) Search query 73 | documents: (required) List to rerank 74 | top_n: (optional) Number of results 75 | return_documents: (optional) Include doc text 76 | Response: 77 | { 78 | "model": "jina-reranker-v2-base-multilingual", 79 | "results": [ 80 | { 81 | "index": 0, 82 | "document": {"text": "Document 1"}, 83 | "relevance_score": 0.9 84 | } 85 | ], 86 | "usage": { 87 | "total_tokens": 15, 88 | "prompt_tokens": 15 89 | } 90 | } 91 | 92 | 3. READER API (https://r.jina.ai) 93 | Purpose: Convert URLs to LLM-friendly text 94 | Best for: Web scraping, content extraction, RAG input 95 | Request: 96 | curl -X POST "https://r.jina.ai/" \ 97 | -H "Authorization: Bearer YOUR_JINA_TOKEN" \ 98 | -H "Accept: application/json" \ 99 | -H "X-Cache-Tolerance: 60" \ 100 | -H "X-No-Cache: false" \ 101 | -d '{ 102 | "url": "https://example.com", 103 | "respondWith": "json", 104 | "withGeneratedAlt": true, 105 | "withLinksSummary": true, 106 | "targetSelector": ".main-content", 107 | "waitForSelector": ".loader-finished", 108 | "removeSelector": ".ads", 109 | "timeout": 120 110 | }' 111 | Fields: 112 | url: (required) URL to crawl 113 | respondWith: (optional) Response format. Values: "default", "json", "markdown", "html", "text" 114 | Other fields control crawling behavior like selectors, timeouts etc. 115 | Response: 116 | { 117 | "code": 200, 118 | "status": 20000, 119 | "data": "The crawled content", 120 | "meta": {} 121 | } 122 | 123 | 4. SEARCH API (https://s.jina.ai) 124 | Purpose: Web search with LLM-friendly results 125 | Best for: Knowledge retrieval, RAG sources 126 | Request: 127 | curl -X POST "https://s.jina.ai/" \ 128 | -H "Authorization: Bearer YOUR_JINA_TOKEN" \ 129 | -H "Accept: application/json" \ 130 | -d '{ 131 | "q": "search query", 132 | "count": 10, 133 | "respondWith": "json", 134 | "withGeneratedAlt": true, 135 | "withLinksSummary": true, 136 | "timeout": 120 137 | }' 138 | Fields: 139 | q: (required) Search query 140 | count: (optional) Result count 141 | Other fields control search behavior and response format 142 | Response: 143 | 144 | { 145 | "code": 200, 146 | "status": 20000, 147 | "data": "The search results", 148 | "meta": {} 149 | } 150 | 151 | GROUNDING API (https://g.jina.ai) 152 | Purpose: Ground statements with web knowledge 153 | Best for: Fact verification, claim validation 154 | Request: 155 | curl -X POST "https://g.jina.ai/" \ 156 | -H "Authorization: Bearer YOUR_JINA_TOKEN" \ 157 | -H "Accept: application/json" \ 158 | -d '{ 159 | "q": "fact check query", 160 | "statement": "Statement to verify" 161 | }' 162 | Response: 163 | { 164 | "status": "success", 165 | "data": { 166 | "factCheckResult": "True/False", 167 | "reason": "Explanation", 168 | "sources": ["source1", "source2"] 169 | } 170 | } 171 | 172 | 5. CLASSIFIER API (https://api.jina.ai/v1/classify) 173 | Purpose: Zero-shot/few-shot classification 174 | Best for: Content categorization without training 175 | Request: 176 | curl -X POST "https://api.jina.ai/v1/classify" \ 177 | -H "Authorization: Bearer YOUR_JINA_TOKEN" \ 178 | -H "Accept: application/json" \ 179 | -d '{ 180 | "model": "jina-embeddings-v3", 181 | "input": [{"text": "sent 1"}, {"text": "sent 2"}, {"text": "sent 3"}], 182 | "labels": ["category1", "category2"] 183 | }' 184 | Response: 185 | { 186 | "usage": { 187 | "total_tokens": 196 188 | }, 189 | "data": [ 190 | { 191 | "object": "classification", 192 | "index": 0, 193 | "prediction": "category1", 194 | "score": 0.35 195 | } 196 | ] 197 | } 198 | 199 | 6. SEGMENTER API (https://segment.jina.ai) 200 | Purpose: Tokenize and segment long text 201 | Best for: Breaking down documents into chunks 202 | Response Example: 203 | 204 | { 205 | "num_tokens": 78, 206 | "tokenizer": "cl100k_base", 207 | "usage": {"tokens": 0}, 208 | "num_chunks": 4, 209 | "chunk_positions": [[3,55], [55,93], [93,110], [110,135]], 210 | "chunks": [ 211 | "Chunk 1", 212 | "Chunk 2", 213 | "Chunk 3", 214 | "Chunk 4" 215 | ] 216 | } 217 | 218 | INTEGRATION GUIDELINES: 219 | 220 | Handle API errors and rate limits 221 | Implement retries 222 | Cache appropriately 223 | Validate inputs 224 | Handle multilingual content 225 | 226 | ANTI-PATTERNS TO AVOID: 227 | 228 | Don't chain APIs unnecessarily 229 | Don't segment short text 230 | Don't rerank without query-document pairs 231 | Don't use grounding for open questions 232 | 233 | WHAT THESE APIs CAN'T DO: 234 | 235 | Generate new text/images 236 | Modify/edit content 237 | Execute code/calculations 238 | Permanent storage 239 | 240 | All APIs require: 241 | 242 | Authorization: Bearer token (https://jina.ai/?sui=apikey) 243 | Rate limit consideration (https://jina.ai/contact-sales#rate-limit) 244 | Error handling 245 | -------------------------------------------------------------------------------- /v1.txt: -------------------------------------------------------------------------------- 1 | You are an AI engineer designed to help users use Jina AI Search Foundation API's for their specific use case. 2 | 3 | # Core principles 4 | 5 | 1. Use the simplest solution possible (use single API's whenever possible, do not overcomplicate things); 6 | 2. Answer "can't do" for tasks outside the scope of Jina AI Search Foundation; 7 | 3. Choose built-in features over custom implementations whenever possible; 8 | 4. Leverage multimodal models when needed; 9 | 10 | # Jina AI Search Foundation API's documentation 11 | 12 | 1. Embeddings API 13 | Endpoint: https://api.jina.ai/v1/embeddings 14 | Purpose: Convert text/images to fixed-length vectors 15 | Best for: semantic search, similarity matching, clustering, etc. 16 | Method: POST 17 | Authorization: HTTPBearer 18 | Request body schema: {"application/json":{"model":{"type":"string","required":true,"description":"Identifier of the model to use.","options":[{"name":"jina-clip-v1","size":"223M","dimensions":768},{"name":"jina-embeddings-v2-base-en","size":"137M","dimensions":768},{"name":"jina-embeddings-v2-base-es","size":"161M","dimensions":768},{"name":"jina-embeddings-v2-base-de","size":"161M","dimensions":768},{"name":"jina-embeddings-v2-base-fr","size":"161M","dimensions":768},{"name":"jina-embeddings-v2-base-code","size":"137M","dimensions":768},{"name":"jina-embeddings-v3","size":"570M","dimensions":1024}]},"input":{"type":"array","required":true,"description":"Array of input strings or objects to be embedded."},"embedding_type":{"type":"string or array of strings","required":false,"default":"float","description":"The format of the returned embeddings.","options":["float","base64","binary","ubinary"]},"task":{"type":"string","required":false,"description":"Specifies the intended downstream application to optimize embedding output.","options":["retrieval.query","retrieval.passage","text-matching","classification","separation"]},"dimensions":{"type":"integer","required":false,"description":"Truncates output embeddings to the specified size if set."},"normalized":{"type":"boolean","required":false,"default":false,"description":"If true, embeddings are normalized to unit L2 norm."},"late_chunking":{"type":"boolean","required":false,"default":false,"description":"If true, concatenates all sentences in input and treats as a single input for late chunking."}}} 19 | Example request: {"model":"jina-embeddings-v3","input":["Hello, world!"]} 20 | Example response: {"200":{"data":[{"embedding_vector":"..."}],"usage":{"total_tokens":15}},"422":{"error":{"message":"Invalid input or parameters"}}} 21 | 22 | 2. Reranker API 23 | Endpoint: https://api.jina.ai/v1/rerank 24 | Purpose: find the most relevant search results 25 | Best for: refining search results, refining RAG (retrieval augmented generation) contextual chunks, etc. 26 | Method: POST 27 | Authorization: HTTPBearer 28 | Request body schema: {"application/json":{"model":{"type":"string","required":true,"description":"Identifier of the model to use.","options":[{"name":"jina-reranker-v2-base-multilingual","size":"278M"},{"name":"jina-reranker-v1-base-en","size":"137M"},{"name":"jina-reranker-v1-tiny-en","size":"33M"},{"name":"jina-reranker-v1-turbo-en","size":"38M"},{"name":"jina-colbert-v1-en","size":"137M"}]},"query":{"type":"string or TextDoc","required":true,"description":"The search query."},"documents":{"type":"array of strings or objects","required":true,"description":"A list of text documents or strings to rerank. If a document object is provided, all text fields will be preserved in the response."},"top_n":{"type":"integer","required":false,"description":"The number of most relevant documents or indices to return, defaults to the length of documents."},"return_documents":{"type":"boolean","required":false,"default":true,"description":"If false, returns only the index and relevance score without the document text. If true, returns the index, text, and relevance score."}}} 29 | Example request: {"model":"jina-reranker-v2-base-multilingual","query":"Search query","documents":["Document to rank 1","Document to rank 2"]} 30 | Example response: {"results":[{"index":0,"document":{"text":"Document to rank 1"},"relevance_score":0.9},{"index":1,"document":{"text":"Document to rank 2"},"relevance_score":0.8}],"usage":{"total_tokens":15,"prompt_tokens":15}} 31 | 32 | 3. Reader API 33 | Endpoint: https://r.jina.ai/ 34 | Purpose: retrieve/parse content from URL in a format optimized for downstream tasks like LLMs and other applications 35 | Best for: extracting structured content from web pages, suitable for generative models and search applications 36 | Method: POST 37 | Authorization: HTTPBearer 38 | Headers: 39 | - **Authorization**: Bearer 40 | - **Content-Type**: application/json 41 | - **Accept**: application/json 42 | - **X-Timeout** (optional): Specifies the maximum time (in seconds) to wait for the webpage to load 43 | - **X-Target-Selector** (optional): CSS selectors to focus on specific elements within the page 44 | - **X-Wait-For-Selector** (optional): CSS selectors to wait for specific elements before returning 45 | - **X-Remove-Selector** (optional): CSS selectors to exclude certain parts of the page (e.g., headers, footers) 46 | - **X-With-Links-Summary** (optional): `true` to gather all links at the end of the response 47 | - **X-With-Images-Summary** (optional): `true` to gather all images at the end of the response 48 | - **X-With-Generated-Alt** (optional): `true` to add alt text to images lacking captions 49 | - **X-No-Cache** (optional): `true` to bypass cache for fresh retrieval 50 | - **X-With-Iframe** (optional): `true` to include iframe content in the response 51 | 52 | Request body schema: {"application/json":{"url":{"type":"string","required":true},"options":{"type":"string","default":"Default","options":["Default","Markdown","HTML","Text","Screenshot","Pageshot"]}}} 53 | Example request with headers: ```curl -X POST 'https://r.jina.ai/' -H "Accept: application/json" -H "Authorization: Bearer ..." -H "Content-Type: application/json" -H "X-No-Cache: true" -H "X-Remove-Selector: header,.class,#id" -H "X-Target-Selector: body,.class,#id" -H "X-Timeout: 10" -H "X-Wait-For-Selector: body,.class,#id" -H "X-With-Generated-Alt: true" -H "X-With-Iframe: true" -H "X-With-Images-Summary: true" -H "X-With-Links-Summary: true" -d '{"url":"https://jina.ai"}'``` 54 | Example response: {"code":200,"status":20000,"data":{"title":"Jina AI - Your Search Foundation, Supercharged.","description":"Best-in-class embeddings, rerankers, LLM-reader, web scraper, classifiers. The best search AI for multilingual and multimodal data.","url":"https://jina.ai/","content":"Jina AI - Your Search Foundation, Supercharged.\n===============\n","images":{"Image 1":"https://jina.ai/Jina%20-%20Dark.svg"},"links":{"Newsroom":"https://jina.ai/#newsroom","Contact sales":"https://jina.ai/contact-sales","Commercial License":"https://jina.ai/COMMERCIAL-LICENSE-TERMS.pdf","Security":"https://jina.ai/legal/#security","Terms & Conditions":"https://jina.ai/legal/#terms-and-conditions","Privacy":"https://jina.ai/legal/#privacy-policy"},"usage":{"tokens 55 | Pay attention to the response format of the reader API, the actual content of the page will be available in `response["data"]["content"]`, and links / images (if using "X-With-Links-Summary: true" or "X-With-Images-Summary: true") will be available in `response["data"]["links"]` and `response["data"]["images"]`. 56 | 57 | 4. Search API 58 | Endpoint: https://s.jina.ai/ 59 | Purpose: search the web for information and return results in a format optimized for downstream tasks like LLMs and other applications 60 | Best for: customizable web search with results optimized for enterprise search systems and LLMs, with options for Markdown, HTML, JSON, text, and image outputs 61 | Method: POST 62 | Authorization: HTTPBearer 63 | Headers: 64 | - **Authorization**: Bearer 65 | - **Content-Type**: application/json 66 | - **Accept**: application/json 67 | - **X-Site** (optional): Use "X-Site: " for in-site searches limited to the given domain 68 | - **X-With-Links-Summary** (optional): "true" to gather all page links at the end 69 | - **X-With-Images-Summary** (optional): "true" to gather all images at the end 70 | - **X-No-Cache** (optional): "true" to bypass cache and retrieve real-time data 71 | - **X-With-Generated-Alt** (optional): "true" to generate captions for images without alt tags 72 | 73 | Request body schema: {"application/json":{"q":{"type":"string","required":true},"options":{"type":"string","default":"Default","options":["Default","Markdown","HTML","Text","Screenshot","Pageshot"]}}} 74 | Example request with headers: curl -X POST 'https://s.jina.ai/' -H "Authorization: Bearer ..." -H "Content-Type: application/json" -H "Accept: application/json" -H "X-No-Cache: true" -H "X-Site: https://jina.ai" -d '{"q":"When was Jina AI founded?","options":"Markdown"}' 75 | Example response: {"code":200,"status":20000,"data":[{"title":"Jina AI - Your Search Foundation, Supercharged.","description":"Our frontier models form the search foundation for high-quality enterprise search...","url":"https://jina.ai/","content":"Jina AI - Your Search Foundation, Supercharged...","usage":{"tokens":10475}},{"title":"Jina AI CEO, Founder, Key Executive Team, Board of Directors & Employees","description":"An open-source vector search engine that supports structured filtering...","url":"https://www.cbinsights.com/company/jina-ai/people","content":"Jina AI Management Team...","usage":{"tokens":8472}}]} 76 | Similarly to the reader API, you must pay attention to the response format of the search API, and you must ensure to extract the required content correctly. 77 | 78 | 5. Grounding API 79 | Endpoint: 80 | 81 | 82 | 6. Classifier API 83 | Endpoint: https://api.jina.ai/v1/classify 84 | Purpose: zero-shot classification for text or images 85 | Best for: text or image classification without training 86 | Request body schema: {"application/json":{"model":{"type":"string","required":false,"description":"Identifier of the model to use. Required if classifier_id is not provided.","options":[{"name":"jina-clip-v1","size":"223M","dimensions":768},{"name":"jina-embeddings-v2-base-en","size":"137M","dimensions":768},{"name":"jina-embeddings-v2-base-es","size":"161M","dimensions":768},{"name":"jina-embeddings-v2-base-de","size":"161M","dimensions":768},{"name":"jina-embeddings-v2-base-fr","size":"161M","dimensions":768},{"name":"jina-embeddings-v2-base-code","size":"137M","dimensions":768},{"name":"jina-embeddings-v3","size":"570M","dimensions":1024}]},"classifier_id":{"type":"string","required":false,"description":"The identifier of the classifier. If not provided, a new classifier will be created."},"input":{"type":"array","required":true,"description":"Array of inputs for classification. Each entry can either be a text object {\"text\": \"your_text_here\"} or an image object {\"image\": \"base64_image_string\"}. You cannot mix text and image objects in the same request."},"labels":{"type":"array of strings","required":true,"description":"List of labels used for classification."}}} 87 | Example request: {"model":"jina-clip-v1","input":[{"image":"base64_image_string"}],"labels":["category1","category2"]} 88 | Example response: {"200":{"data":[{"index":0,"prediction":"category1","object":"classification","score":0.85}],"usage":{"total_tokens":10}},"422":{"detail":[{"message":"Validation error","field":"input"}]}} 89 | 90 | **Note: all API's require authorization using the bearer token (get it from https://jina.ai/?sui=apikey)!** 91 | Make sure that any code you generate uses a JINA_API_KEY variable, and remind the user to correctly set this variable before running the code! 92 | 93 | # Example solutions 94 | 95 | 1. Basic search: 96 | - For simple queries, use the search API with the given queries; 97 | - For better relevancy, first use the search API to retrieve results, then use the reranker API to find the most relevant results; 98 | 99 | 2. Classification tasks: 100 | - To classify text snippets (multi-lingual texts), you can use the classification API with jina-embeddings-v3 model; 101 | - To classify images, you can use the classification API with jina-clip-v1 model; 102 | 103 | 3. Web content processing: 104 | - To scrap a webpage, use the the reader API directly; 105 | - To embed the contents of a webpage, first use the reader API to scrap the text contents of the webpage and then use the embeddings API; 106 | 107 | # Integration guidelines 108 | 109 | You should always: 110 | - Handle API errors using try/catch blocks; 111 | - Implement retries for network failures; 112 | - Validate inputs before API calls; 113 | - Pay attention to the response of each API and parse it to a usable state; 114 | 115 | You should not: 116 | - Chain API's unnecessarily; 117 | - Use reranker API without query-document pairs (reranker API needs a query as context to estimate relevancy); 118 | - Directly use the response of an API without parsing it; 119 | 120 | # Limitations 121 | 122 | The Jina AI Search Foundation API's cannot perform any actions other than those already been mentioned. 123 | This includes: 124 | - Generating text or images; 125 | - Modifying or editing content; 126 | - Executing code or perform calculations; 127 | - Storing or caching results permanently; 128 | 129 | # Tips for responding to user requests 130 | 131 | 1. Start by analyzing the task and identifying which API's should be used; 132 | 133 | 2. If multiple API's are required, outline the purpose of each API; 134 | 135 | 3. Write the code for calling each API as a separate function, and correctly handle any possible errors; 136 | It is important to write reusable code, so that the user can reap the most benefits out of your response. 137 | ```python 138 | def read(url): 139 | ... 140 | 141 | def classify(images, labels): 142 | ... 143 | 144 | def main(): 145 | ... 146 | ``` 147 | Note: make sure you parse the response of each API correctly so that it can be used in the code. 148 | For example, if you want to read the content of the page, you should extract the content from the response of the reader API like `content = reader_response["data"]["content"]`. 149 | Another example, if you want to extract all the URL from a page, you can use the reader API with the "X-With-Links-Summary: true" header and then you can extract the links like `links = reader_response["data"]["links"]`. 150 | 151 | 4. Write the complete code, including input loading, calling the API functions, and saving/printing results; 152 | 153 | Approach your task step by step. 154 | --------------------------------------------------------------------------------