{"timing":{"querytime":0.002,"summaryfetchtime":0.002,"searchtime":0.005},"root":{"id":"toplevel","relevance":1.0,"fields":{"totalCount":553},"coverage":{"coverage":100,"documents":553,"full":true,"nodes":2,"results":1,"resultsFull":1},"children":[{"id":"id:open:doc::open/en/contributing/configapi-dev-cpp.html","relevance":0.99900149775337,"source":"documentation","fields":{"sddocname":"doc","content":" This document describes how to use the C++ cloud config API. We are assuming you have created a config definition file (def file), which is the schema for one of your configs. Developing with the C++ Cloud Config API requires you to Generate C++ code from your config definitions Subscribe to the config using the API Generating Config In my example application, I have the following hierarchy related to config: src/config-defs/motd.def Generate code while standing in the src/ folder: $ make-config.pl $(pwd) $(pwd)/config-defs/motd.def This will generate a config-defs/config-motd.h and config","documentid":"id:open:doc::open/en/contributing/configapi-dev-cpp.html","path":"/en/contributing/configapi-dev-cpp.html","title":"Using the C++ Cloud config API","headers":["Generating Config","Subscribing and Getting Config","Selecting Config Source","Unit Testing","Printing Config"],"namespace":"open","outlinks":["/en/contributing/configapi-dev.html"],"term_count":1002,"last_updated":1711608088,"summaryfeatures":{"attribute(term_count)":1002.0,"query(q_term_count)":1000.0,"vespa.summaryFeatures.cached":0.0}}},{"id":"id:open:doc::open/en/stateless-model-evaluation.html","relevance":0.9985029940119761,"source":"documentation","fields":{"sddocname":"doc","content":" Vespa's speciality is evaluating machine-learned models quickly over large numbers of data points. However, it can also be used to evaluate models once on request in stateless containers. By enabling a feature in services.xml, all machine-learned models - TensorFlow, Onnx, XGBoost, LightGBM and Vespa stateless models - added to the models/ directory of the application package, are made available through both a REST API and a Java API where you can compute inferences from your own code. An example application package can be found at in the model-evaluation system test. The model evaluation tag To","documentid":"id:open:doc::open/en/stateless-model-evaluation.html","path":"/en/stateless-model-evaluation.html","title":"Stateless Model Evaluation","headers":["The model evaluation tag","Model inference using the REST API","Model evaluation REST API parameters","Model inference using Java","Unit testing model evaluation in Java","ONNX inference options"],"namespace":"open","outlinks":["/en/reference/application-packages-reference.html","/en/reference/services.html","/en/reference/stateless-model-reference.html","/en/jdisc","/en/lightgbm.html","/en/onnx.html","/en/reference/document-json-format.html","/en/reference/tensor.html","/en/tensorflow.html","/en/xgboost.html","/en/jdisc/injecting-components.html"],"term_count":1003,"last_updated":1711608090,"summaryfeatures":{"attribute(term_count)":1003.0,"query(q_term_count)":1000.0,"vespa.summaryFeatures.cached":0.0},"inlinks":{"/en/reference/stateless-model-reference.html":1,"/en/lightgbm.html":1}}},{"id":"id:open:doc::open/en/reference/services-processing.html","relevance":0.9944723618090452,"source":"documentation","fields":{"sddocname":"doc","content":" This document explains the syntax and semantics of the processing subelement of the container part of services.xml. processing is for configuring a pure request-response processing application, with no particular dependency to search or query handling. The processing block is used to configure processors: processing binding processor [id, class, bundle, provides, before, after] provides before after renderer [id, class, bundle] chain [id, inherits, excludes] processor [idref, id, class, bundle, provides, before, after] provides before after inherits","documentid":"id:open:doc::open/en/reference/services-processing.html","path":"/en/reference/services-processing.html","title":"services.xml - processing","headers":["binding","processor","renderer","processor (in chain)","provides","chain","inherits","excludes","phase","before","after"],"namespace":"open","outlinks":["/en/reference/services-processing.html","/en/reference/services-docproc.html","/en/components/chained-components.html","/en/application-packages.html","/en/reference/services-container.html","/en/jdisc/processing.html","/en/reference/services-search.html","/en/document-processing.html"],"term_count":989,"last_updated":1711608090,"summaryfeatures":{"attribute(term_count)":989.0,"query(q_term_count)":1000.0,"vespa.summaryFeatures.cached":0.0}}},{"id":"id:open:doc::open/en/use-case-shopping.html","relevance":0.9939668174962293,"source":"documentation","fields":{"sddocname":"doc","content":"The e-commerce, or shopping, use case is an example of an e-commerce site complete with sample data and a web front end to browse product data and reviews. To quick start the application, follow the instructions in the README in the sample app. To browse the application, navigate to localhost:8080/site. This site is implemented through a custom request handler and is meant to be a simple example of creating a front end / middleware that sits in front of the Vespa back end. As such it is fairly independent of Vespa features, and the code is designed to be fairly easy to follow and as non-magical as possible. All the queries against Vespa are sent as HTTP requests, and the JSON results from","documentid":"id:open:doc::open/en/use-case-shopping.html","path":"/en/use-case-shopping.html","title":"Use Case - shopping","headers":["Highlighted features"],"namespace":"open","outlinks":["/en/text-matching.html","/en/embedding.html","/en/grouping.html","/en/searcher-development.html","/en/schemas.html","/en/stateless-model-evaluation.html","/en/reference/document-json-format.html","/en/reference/query-language-reference.html","/en/query-language.html","/en/document-processing.html","/en/reference/schema-reference.html","/en/nearest-neighbor-search.html","/en/configuring-components.html","/en/jdisc/developing-request-handlers.html","/en/ranking.html"],"term_count":988,"last_updated":1711608090,"summaryfeatures":{"attribute(term_count)":988.0,"query(q_term_count)":1000.0,"vespa.summaryFeatures.cached":0.0}}},{"id":"id:open:doc::open/en/performance/profiling.html","relevance":0.9871731623088308,"source":"documentation","fields":{"sddocname":"doc","content":" Guidelines when profiling: Define clearly what to profile. Find a load that represents what to profile. This is often the hardest part, as there is a lot of noise if stressing other components. Make sure that there are no other bottlenecks that blocks stressing the profiled component. It makes little sense to do CPU profiling if the network or the disk is the limitation factor. If possible, write special unit-tests like benchmark programs that stress exactly what to profile. If the system is multithreaded: Always profile single threaded first - that gives a baseline for doing the","documentid":"id:open:doc::open/en/performance/profiling.html","path":"/en/performance/profiling.html","title":"Profiling","headers":["CPU profiling","CPU Profiling using perf","Container privileges","Profiling the Query Container","Install YourKit profiler on the Container","Install YourKit UI on the Desktop","Using Yourkit"],"namespace":"open","outlinks":["/en/proton.html","/en/performance/container-tuning.html","/en/operations-selfhosted/vespa-cmdline-tools.html","/en/performance/valgrind.html","/en/performance/vespa-benchmarking.html"],"term_count":1026,"last_updated":1711608089,"summaryfeatures":{"attribute(term_count)":1026.0,"query(q_term_count)":1000.0,"vespa.summaryFeatures.cached":0.0}}},{"id":"id:open:doc::open/en/reranking-in-searcher.html","relevance":0.9858084135833756,"source":"documentation","fields":{"sddocname":"doc","content":"This guide demonstrates how to deploy a stateless searcher implementing a last stage of phased ranking. The searcher re-ranks the global top 200 documents which have been ranked by the content nodes using the configurable ranking specification in the document schema(s). The reranking searcher uses multiphase searching: Matching query protocol phase: The matching protocol phase which asks each content node involved in the query to return the locally best ranking hits (ranked by the configurable ranking expressions defined in the schema). This matching query protocol phase can include several ranking phases which are executed per content node","documentid":"id:open:doc::open/en/reranking-in-searcher.html","path":"/en/reranking-in-searcher.html","title":"Re-ranking using a custom Searcher","headers":["A minimal Vespa application","Starting Vespa","Feed data","Query the data","Teardown"],"namespace":"open","outlinks":["/en/searcher-development.html","/en/reference/application-packages-reference.html","/en/reference/services.html","/en/document-summaries.html","/en/reference/schema-reference.html","/en/components/chained-components.html","/en/schemas.html","/en/vespa-cli.html","/en/reference/rank-features.html","/en/phased-ranking.html","/en/performance/sizing-search.html","/en/ranking.html"],"term_count":972,"last_updated":1711608090,"summaryfeatures":{"attribute(term_count)":972.0,"query(q_term_count)":1000.0,"vespa.summaryFeatures.cached":0.0}}},{"id":"id:open:doc::open/en/xgboost.html","relevance":0.9808823529411764,"source":"documentation","fields":{"sddocname":"doc","content":"Vespa supports importing Gradient Boosting Decision Tree (GBDT) models trained with XGBoost. Exporting models from XGBoost Vespa supports importing XGBoost’s JSON model dump, e.g. Python API xgboost.Booster.dump_model. When dumping the trained model, XGBoost allows users to set the dump_format to json, and users can specify the feature names to be used in fmap. Here is an example of an XGBoost JSON model dump with 2 trees and maximum depth 1: [ { \"nodeid\": 0, \"depth\": 0, \"split","documentid":"id:open:doc::open/en/xgboost.html","path":"/en/xgboost.html","title":"Ranking with XGBoost Models","headers":["Exporting models from XGBoost","Feature mappings from XGBoost to Vespa","Importing XGBoost models","Ranking with XGBoost models","XGBoost models","Debugging Vespa inference score versus XGBoost predict score"],"namespace":"open","outlinks":["/en/schemas.html","/en/application-packages.html","/en/performance/practical-search-performance-guide.html","/en/reference/rank-features.html","/en/phased-ranking.html","/en/reference/query-api-reference.html","/en/performance/sizing-search.html","/en/reference/ranking-expressions.html"],"term_count":1039,"last_updated":1711608091,"summaryfeatures":{"attribute(term_count)":1039.0,"query(q_term_count)":1000.0,"vespa.summaryFeatures.cached":0.0},"inlinks":{"/en/lightgbm.html":1}}},{"id":"id:open:doc::open/en/ranking.html","relevance":0.9796022437531872,"source":"documentation","fields":{"sddocname":"doc","content":"Ranking is where Vespa does computing, or inference over documents retrieved by a query. The goal is to order (rank) the documents retrieved. The computations are expressed in functions called ranking expressions, bundled into rank profiles defined in schemas. These can range from simple math expressions combining some rank features, to tensor expressions or large machine-learned Onnx models. Two-phase ranking Rank profiles can define two phases that are evaluated locally on content nodes, which means that no data needs to","documentid":"id:open:doc::open/en/ranking.html","path":"/en/ranking.html","title":"Ranking","headers":["Two-phase ranking","Global-phase ranking","Machine-Learned model inference","Model Training and Deployment","Rank profiles","Text ranking","Weight, significance and connectedness"],"namespace":"open","outlinks":["/en/searcher-development.html","/en/query-profiles.html","/en/schemas.html","/en/application-packages.html","/en/streaming-search.html","/en/reference/bm25.html","/en/onnx.html","/en/ranking-expressions-features.html","/en/reference/sorting.html","/en/reference/query-language-reference.html","/en/nativerank.html","/en/reference/query-api-reference.html","/en/reference/application-packages-reference.html","/en/reference/string-segment-match.html","/en/reference/schema-reference.html","/en/tensor-examples.html","/en/testing.html","/en/lightgbm.html","/en/reference/rank-features.html","/en/reference/nativerank.html","/en/xgboost.html","/en/phased-ranking.html"],"term_count":960,"last_updated":1711608089,"summaryfeatures":{"attribute(term_count)":960.0,"query(q_term_count)":1000.0,"vespa.summaryFeatures.cached":0.0}}},{"id":"id:open:doc::open/en/operations-selfhosted/files-processes-and-ports.html","relevance":0.9764705882352941,"source":"documentation","fields":{"sddocname":"doc","content":" This is a reference of directories used in a Vespa installation, processes that run on the Vespa nodes and ports / environment variables used. Also see log files. Directories Directory Description $VESPA_HOME/bin/ Command line utilities and scripts $VESPA_HOME/libexec/vespa/ Command line utilities and scripts $VESPA_HOME/sbin/ Server programs, daemons, etc $VESPA_HOME/lib64/ Dynamically linked libraries, typically third-party","documentid":"id:open:doc::open/en/operations-selfhosted/files-processes-and-ports.html","path":"/en/operations-selfhosted/files-processes-and-ports.html","title":"Files, Processes, Ports, Environment","headers":["Directories","Processes and ports","System limits","Core dumps","Environment variables"],"namespace":"open","outlinks":["/en/reference/services.html","/en/jdisc/http-server-and-filters.html","/en/content/content-nodes.html","/en/application-packages.html","/en/operations-selfhosted/config-proxy.html","/en/operations-selfhosted/vespa-cmdline-tools.html","/en/document-api-guide.html","/en/operations-selfhosted/config-sentinel.html","/en/operations-selfhosted/admin-procedures.html","/en/proton.html","/en/operations-selfhosted/multinode-systems.html","/en/operations-selfhosted/slobrok.html","/en/jdisc/index.html","/en/reference/logs.html","/en/performance/container-tuning.html","/en/operations-selfhosted/configuration-server.html","/en/operations-selfhosted/mtls.html","/en/operations-selfhosted/monitoring.html"],"term_count":954,"last_updated":1711608088,"summaryfeatures":{"attribute(term_count)":954.0,"query(q_term_count)":1000.0,"vespa.summaryFeatures.cached":0.0}}},{"id":"id:open:doc::open/en/reference/rank-feature-configuration.html","relevance":0.9732490272373541,"source":"documentation","fields":{"sddocname":"doc","content":" For some rank features, it is possible to set configuration variables for how the features are calculated. For features which are per field or attribute, the variables are set separately per field/attribute. Variables Rank Features configuration variables are set by adding the following to the rank profile: rank-properties { <featurename>.<configuration-property>: <value> } Where <featurename> is the name of a feature class (feature name up to the first dot), <configuration-property> is a property from the list below, appropriate for the feature, and <value> is either a number of a quoted string. Example: set some properties on the fieldMatch and bm25 feature class of two different","documentid":"id:open:doc::open/en/reference/rank-feature-configuration.html","path":"/en/reference/rank-feature-configuration.html","title":"Rank Feature Configuration","headers":["Variables","Configuration Properties"],"namespace":"open","outlinks":["/en/streaming-search.html","/en/reference/services-content.html","/en/reference/rank-features.html"],"term_count":1055,"last_updated":1711608089,"summaryfeatures":{"attribute(term_count)":1055.0,"query(q_term_count)":1000.0,"vespa.summaryFeatures.cached":0.0}}}]}}